Tag Archives: template

これらのキーワードは次のトークンがタイプなのかテンプレートなのかを指定する。テンプレート関数内でテンプレート引数Tに依存するトークンが出てきたとき、コンパイラはそのトークンがタイプなのかテンプレートなのか関数なのか変数なのかわからない。

T::A<0>(x);

1	T::A<0>(x);

Aが変数なら、例えば0に置き換えてみると以下のようになる。

0<0>(x);

0<0>(x);

<や>は小なりと大なりと解釈され、有効な式になる。

Aが関数の場合は<0>はテンプレート引数となりxを引数とする関数コールになる。

Aがテンプレートクラスの場合はそのクラスインスタンスxの定義になる。

テンプレートが実体化されたときにわかりそうだが、意図した動作と違う時にエラーの発見が難しくもなりそうなので、Tに依存するトークンでそれがあいまいな場合（どんな時あいまいなのかはよくわからない）はtypenameやtemplateといったキーワードをつける約束になっているようだ。この例の場合はAはintなどの基本タイプにはなれない。

このような用途で使うのがtypenameとtemplate。

typename

T::Aがタイプの場合に指定する。これはよく使う。意味不明なエラーが出た場合につけると直ることが多い。

template

カギカッコなしのtemplateは他の使い方もあるが、ここではTに依存する（Tの中にある）テンプレートクラスやテンプレート関数を指定するときにつけるようだ。テンプレートクラスの場合はタイプでもあるので、両方つけることもある。

typename T::template A<0>(x);

1	typename T::template A<0>(x);

こういうものをつけなければならないときはusingを使って別名にしておいた方がいいだろう。

実験したまとめ

Aが変数の場合

typenanmeもtemplateもつけてはいけない（つけるとエラー）

Aが関数テンプレートの場合

typenameとtemplateと両方つけるか、何もつけない（typenameだけだとエラー）

Aがクラステンプレートの場合

両方つけないとエラー

ソース

https://github.com/ambiesoft/blogprogs/tree/master/6151/templatetypename

#include <iostream>

struct S1 {
    static constexpr int A = 0;
};
struct S2 {
    template<int N>
    static void A(int) {}
};
struct S3 {
    template<int N>
    struct A {};
};

// Uncomment one of three
// #define SISS1
#define SISS2
// #define SISS3

#ifdef SISS1
template <class T>
void foo() {
    //// error C2903: 'A': symbol is neither a class template nor a function template 
    //typename T::template A<0>(x);
     
    //// error C7511: 'A': 'typename' keyword must be followed by a qualified name
    //typename A<0>(x);

    int x = 0;
    T::A<0>(x);
}

int main()
{
    foo<S1>();
}
#endif


#ifdef SISS2
template <class T>
void foo() {
    int x = 0;
    typename T::template A<0>(x);
    T::A<0>(x);

    //// error C7511: 'A': 'typename' keyword must be followed by a qualified name
    //typename A<0>(x);
}

int main()
{
    foo<S2>();
}
#endif


#ifdef SISS3
template <class T>
void foo() {
    typename T::template A<0>(x);

    //// error C7511: 'A': 'typename' keyword must be followed by a qualified name
    //typename A<0>(x);
    
    //int x = 0;
    //// error C2371: 'x': redefinition; different basic types
    //T::A<0>(x);

    //// error C3861: 'x': identifier not found
    //T::A<0>(x);
}

int main()
{
    foo<S3>();
}
#endif

#include <iostream>

struct S1 {

static constexpr int A = 0;

};

struct S2 {

template<int N>

static void A(int) {}

};

struct S3 {

template<int N>

struct A {};

};

// Uncomment one of three

// #define SISS1

#define SISS2

// #define SISS3

#ifdef SISS1

template <class T>

void foo() {

//// error C2903: 'A': symbol is neither a class template nor a function template

//typename T::template A<0>(x);

//// error C7511: 'A': 'typename' keyword must be followed by a qualified name

//typename A<0>(x);

int x = 0;

T::A<0>(x);

}

int main()

{

foo<S1>();

}

#endif

#ifdef SISS2

template <class T>

void foo() {

int x = 0;

typename T::template A<0>(x);

T::A<0>(x);

//// error C7511: 'A': 'typename' keyword must be followed by a qualified name

//typename A<0>(x);

}

int main()

{

foo<S2>();

}

#endif

#ifdef SISS3

template <class T>

void foo() {

typename T::template A<0>(x);

//// error C7511: 'A': 'typename' keyword must be followed by a qualified name

//typename A<0>(x);

//int x = 0;

//// error C2371: 'x': redefinition; different basic types

//T::A<0>(x);

//// error C3861: 'x': identifier not found

//T::A<0>(x);

}

int main()

{

foo<S3>();

}

#endif

参考にした動画

to_stringとto_wstring

2021年7月15日

admin

C++ No Comments

to_stringとto_wstringはintなどを文字列にして返す標準ライブラリ関数。便利なのだが、charとwchar_tで分かれているので汎用コードを書きたいときにそのまま書きたくない。Windowsはもはやwchar_tが主流だしLinuxではcharが主流でwchar_tは４バイトになることが多い。よってこれらをそのまま使うと汎用性がなくなる。

テンプレート関数

これらの関数をテンプレート関数にしたいとき、テンプレート引数は２つになり、最初の引数はcharかwchar_t、次の引数はintやdoubleとなる。テンプレート関数は部分特殊化ができないので、これらの組み合わせすべて書くしかなくなって効率が悪い。

テンプレートクラス

テンプレートクラスは部分特殊化ができるので、これを利用して汎用関数をつくりたい。文字列クラスのデフォルトをWindowsならwchar_tとしそれ以外ならcharとして扱えば同じ関数記述にできる。

汎用テンプレートクラスの定義

template<typename C, typename T>
struct class_stdToString
{
	static_assert(sizeof(T) == 0, "char or wchar_t");
};

template<typename C, typename T>

struct class_stdToString

{

static_assert(sizeof(T) == 0, "char or wchar_t");

};

これは実体化されることを想定してないので、static_assert常に失敗。
次にcharの部分特殊化

template<typename T>
struct class_stdToString<char, T>
{
	static std::basic_string<char> call(const T& t)
	{
		return std::to_string(t);
	}
};

template<typename T>

struct class_stdToString<char, T>

{

static std::basic_string<char> call(const T& t)

{

return std::to_string(t);

}

};

同様にwchar_t

template<typename T>
struct class_stdToString<wchar_t, T>
{
	static std::basic_string<wchar_t> call(const T& t)
	{
		return std::to_wstring(t);
	}
};

template<typename T>

struct class_stdToString<wchar_t, T>

{

static std::basic_string<wchar_t> call(const T& t)

{

return std::to_wstring(t);

}

};

ここまではユーザは意識しないコード。次がユーザが呼ぶ関数。

template<typename C = SYSTEM_CHAR_TYPE, typename T>
std::basic_string<C> stdToString(const T& t)
{
	return class_stdToString<C, T>::call(t);
}

template<typename C = SYSTEM_CHAR_TYPE, typename T>

std::basic_string<C> stdToString(const T& t)

{

return class_stdToString<C, T>::call(t);

}

SYSTEM_CHAR_TYPEは事前にtypedefされているcharかwchar_t。

テストコード

TEST(stdosd, stdToString)
{
#ifdef _WIN32
	EXPECT_STREQ(L"1", stdToString(1).c_str());
#else
	EXPECT_STREQ("1", stdToString(1).c_str());
#endif

	EXPECT_STREQ("0", stdToString<char>(0).c_str());
	EXPECT_STREQ("-1", stdToString<char>(-1).c_str());
	EXPECT_STREQ(L"0", stdToString<wchar_t>(0).c_str());
	EXPECT_STREQ(L"-1", stdToString<wchar_t>(-1).c_str());
}

TEST(stdosd, stdToString)

{

#ifdef _WIN32

EXPECT_STREQ(L"1", stdToString(1).c_str());

#else

EXPECT_STREQ("1", stdToString(1).c_str());

#endif

EXPECT_STREQ("0", stdToString<char>(0).c_str());

EXPECT_STREQ("-1", stdToString<char>(-1).c_str());

EXPECT_STREQ(L"0", stdToString<wchar_t>(0).c_str());

EXPECT_STREQ(L"-1", stdToString<wchar_t>(-1).c_str());

}

bool追加

to_stringにはboolがなく、intとして解釈されるようなのでboolも完全特殊化で定義

template<>
struct class_stdToString<char, bool>
{
	static std::basic_string<char> call(const bool& t)
	{
		return t ? "true" : "false";
	}
};
template<>
struct class_stdToString<char, bool>
{
	static std::basic_string<char> call(const bool& t)
	{
		return t ? "true" : "false";
	}
};

template<>

struct class_stdToString<char, bool>

{

static std::basic_string<char> call(const bool& t)

{

return t ? "true" : "false";

}

};

template<>

struct class_stdToString<char, bool>

{

static std::basic_string<char> call(const bool& t)

{

return t ? "true" : "false";

}

};

ソース：https://github.com/ambiesoft/lsMisc/blob/master/stdosd/stdosd.h

考察

C＋＋にはもともとstreamがあって、それを使えばすべて汎用関数で書けそう。しかしto_stringとかの実装はそうなってないようなのでスルー。

これとは逆の関数。文字列からintなどに変える関数は引数に文字列しか入らないので型の推論ができないのでそれぞれの型ごとに別関数にするしかないものと思われる。

C++ テンプレート関数をソース・ファイルに書く

2021年7月13日

admin

C++ No Comments

前提

まだ完全にはわからない

Tが汎用の場合

std::vector<T>などのTに何でも入れられることを前提にしてつくられているクラスはヘッダに書くしかないと思う。

Tが一部の型のみの場合

この場合はソースファイルにかける。

ここでは文字列の長さをを返す関数でchar*とwchar_t*をとるGetStringLength()を考える。

ヘッダ

template<typename T> size_t GetStringLength(const T* p)
{
	// should never come here
	static_assert(sizeof(T) == 0, "only char* or wchar_t*");
}
template<> size_t GetStringLength<char>(const char* p);
template<> size_t GetStringLength<wchar_t>(const wchar_t* p);

extern template size_t GetStringLength<char>(const char* p);
extern template size_t GetStringLength<wchar_t>(const wchar_t* p);

template<typename T> size_t GetStringLength(const T* p)

{

// should never come here

static_assert(sizeof(T) == 0, "only char* or wchar_t*");

}

template<> size_t GetStringLength<char>(const char* p);

template<> size_t GetStringLength<wchar_t>(const wchar_t* p);

extern template size_t GetStringLength<char>(const char* p);

extern template size_t GetStringLength<wchar_t>(const wchar_t* p);

最初のテンプレート関数は汎用のTを受け取る。もしテンプレート関数が実体化されたときはstatic_assertでエラーになるようにしている（sizeof(T)は決して０にならない。falseを指定してしまうと実体化しなくてもエラーになってしまう（コンパイラ依存））。char*とwchar_t*で特殊化するので、それ以外のポインタで呼ばれたときに実体化される。

次の２つは特殊化の宣言。定義はソースに書く。
次の２つは特殊化が実体化されるときの場所の指定。externでどこかにそれがあることを示している。

ソース

#include "header.h"
#include <string.h>
template<> size_t GetStringLength<char>(const char* p)
{
	return strlen(p);
}
template<> size_t GetStringLength<wchar_t>(const wchar_t* p)
{
	return wcslen(p);
}

template size_t GetStringLength<char>(const char* p);
template size_t GetStringLength<wchar_t>(const wchar_t* p);

#include "header.h"

#include <string.h>

template<> size_t GetStringLength<char>(const char* p)

{

return strlen(p);

}

template<> size_t GetStringLength<wchar_t>(const wchar_t* p)

{

return wcslen(p);

}

template size_t GetStringLength<char>(const char* p);

template size_t GetStringLength<wchar_t>(const wchar_t* p);

最初の２つは特殊化の定義。
次の２つは特殊化が定義されるときここに実体化されることを意味する。

main.cpp

#include <iostream>
#include "header.h"
int main()
{
    const char* p = "aaa";
    const wchar_t* pw = L"bbb";
    std::cout << "Length of p is " << GetStringLength(p) << '\n';
    std::cout << "Length of pw is " << GetStringLength(pw) << '\n';

    int* pi;
    // GetStringLength(pi);  // static_assert
}

#include <iostream>

#include "header.h"

int main()

{

const char* p = "aaa";

const wchar_t* pw = L"bbb";

std::cout << "Length of p is " << GetStringLength(p) << '\n';

std::cout << "Length of pw is " << GetStringLength(pw) << '\n';

int* pi;

// GetStringLength(pi); // static_assert

}

今回の場合は実装がほぼないのでテンプレートにする意味があんまりないが、２つの実装がほぼ同じで、一部だけ書き換えたいときは汎用Tの方に実装を書くこともできる。その場合にこのテンプレートを使うこともできる。

Tが一部の型のみの場合（バージョン２）

ヘッダー

template<typename T> size_t GetStringLength(const T* p);

extern template size_t GetStringLength<char>(const char* p);
extern template size_t GetStringLength<wchar_t>(const wchar_t* p);

template<typename T> size_t GetStringLength(const T* p);

extern template size_t GetStringLength<char>(const char* p);

extern template size_t GetStringLength<wchar_t>(const wchar_t* p);

ソース＆main.cpp

#include "header.h"
#include <string.h>
template<typename T> size_t GetStringLength(const T* p)
{
	if (p == nullptr)
		return 0;
	size_t size = 0;
	for (; *p; ++p)
		++size;
	return size;
}

template size_t GetStringLength<char>(const char* p);
template size_t GetStringLength<wchar_t>(const wchar_t* p);

#include "header.h"

#include <string.h>

template<typename T> size_t GetStringLength(const T* p)

{

if (p == nullptr)

return 0;

size_t size = 0;

for (; *p; ++p)

++size;

return size;

}

template size_t GetStringLength<char>(const char* p);

template size_t GetStringLength<wchar_t>(const wchar_t* p);

#include <iostream>
#include "header.h"
int main()
{
    const char* p = "aaa";
    const wchar_t* pw = L"bbb";
    std::cout << "Length of p is " << GetStringLength(p) << '\n';
    std::cout << "Length of pw is " << GetStringLength(pw) << '\n';

    int* pi = 0;
    // GetStringLength(pi);  // link error
}

#include <iostream>

#include "header.h"

int main()

{

const char* p = "aaa";

const wchar_t* pw = L"bbb";

std::cout << "Length of p is " << GetStringLength(p) << '\n';

std::cout << "Length of pw is " << GetStringLength(pw) << '\n';

int* pi = 0;

// GetStringLength(pi); // link error

}

ソース：https://github.com/ambiesoft/blogprogs/tree/master/6038

考察

テンプレート関数の定義をソース・ファイルに書くと、他のソース・ファイルからは見ることができないのでリンカーでつなげることになる。よって鉤括弧なしのtemplateは実装を実体化し外部に公開して他のソース・ファイルから見えるようにしているのだと思われる。

鉤括弧ありのテンプレートはあくまでコンパイルフェーズで解決するものであり、宣言だけのテンプレートを実体化しても宣言だけになり、それがリンクされることもないのだと思われる。

C++のテンプレート関数で特定の型でエラーにする

2021年7月13日

admin

C++ No Comments

std::is_class

is_class<T>を使うとTがクラス（構造体含む）かどうか判定してくれる。

#include <iostream>

template<typename T>
void func(T t)
{
    // Tはclassでは駄目。（以下structも駄目）
    static_assert(!std::is_class<T>::value, 
        "T must not a class");
    // Tはclassへのポインターじゃ駄目
    static_assert(!std::is_class< std::remove_pointer<T>::type >::value, 
        "T must not a ptr to class");
    // Tはclassへのポインターのポインターじゃ駄目
    static_assert(!std::is_class< std::remove_pointer< std::remove_pointer<T>::type >::type >::value,
        "T must not a ptr to ptr to class");
}

class C {};
struct S {};
enum E {};
enum class EC {};
int main()
{
    int i;

    func(1);
    func(&i);
    func(false);

    C c;
    // func(c); // error
    // func(&c);  // error
    C** ppc;
    // func(ppc); // error
    func(&ppc);

    S s;
    // func(s); // error
    // func(&s);  // error

    E e;
    func(e);
    func(&e);

    EC ec;
    func(ec);
    func(&ec);
}

#include <iostream>

template<typename T>

void func(T t)

{

// Tはclassでは駄目。（以下structも駄目）

static_assert(!std::is_class<T>::value,

"T must not a class");

// Tはclassへのポインターじゃ駄目

static_assert(!std::is_class< std::remove_pointer<T>::type >::value,

"T must not a ptr to class");

// Tはclassへのポインターのポインターじゃ駄目

static_assert(!std::is_class< std::remove_pointer< std::remove_pointer<T>::type >::type >::value,

"T must not a ptr to ptr to class");

}

class C {};

struct S {};

enum E {};

enum class EC {};

int main()

{

int i;

func(1);

func(&i);

func(false);

C c;

// func(c); // error

// func(&c); // error

C** ppc;

// func(ppc); // error

func(&ppc);

S s;

// func(s); // error

// func(&s); // error

E e;

func(e);

func(&e);

EC ec;

func(ec);

func(&ec);

}

テンプレート関数funcはクラスや、クラスへのポインターや、クラスへのポインターのポインターを渡すとエラーになる。ただしクラスへのポインターのポインターのポインターを渡すことはできる。

ソース

https://github.com/ambiesoft/blogprogs/tree/master/6022/isClass

テンプレートのvariadic引数で型をチェックする

2021年7月9日

admin

C++ No Comments

普通の型チェック

template <typename T>
void func(T t)
{
	static_assert(!std::is_pointer_v<T>, "T must not a pointer");
}
int main()
{
	func(1);
	// func("");  // error
	int a = 1;
	func(a);
	// func(&a);  // error
	int* pa = &a;
	func(*pa);

template <typename T>

void func(T t)

{

static_assert(!std::is_pointer_v<T>, "T must not a pointer");

}

int main()

{

func(1);

// func(""); // error

int a = 1;

func(a);

// func(&a); // error

int* pa = &a;

func(*pa);

Tがポインタだとエラーになる。

variadicの場合

static void CheckKata(){}
template<typename T, typename... ARGS>
static void CheckKata(T firstArg, ARGS... args)
{
	using NoConstT = typename std::add_pointer<std::remove_cv<std::remove_pointer<T>::type>::type>::type;
	static_assert(
		std::is_same_v<std::remove_cv_t<T>, wchar_t> ||
		!std::is_same_v<NoConstT, wchar_t*>, 
		"argument must not wchar_t*");
	CheckKata(args...);
}

static void CheckKata(){}

template<typename T, typename... ARGS>

static void CheckKata(T firstArg, ARGS... args)

{

using NoConstT = typename std::add_pointer<std::remove_cv<std::remove_pointer<T>::type>::type>::type;

static_assert(

std::is_same_v<std::remove_cv_t<T>, wchar_t> ||

!std::is_same_v<NoConstT, wchar_t*>,

"argument must not wchar_t*");

CheckKata(args...);

}

最初の引数の型Tに対してチェックしている。CheckKataに渡される引数がwchar_t*だったりポインタのポインタだったらエラーになる。ただwchar_tはセーフにしている。

remove_cvなどの挙動がいまいちよくわからないのでこの書き方であっているのか不明。以下のようなコードで実行時の型を表示してくれる。

	std::cout << typeid(T).name() << '\n';
	std::cout << typeid(std::decay_t<T>).name() << '\n';
	std::cout << typeid(std::remove_cv_t<T>).name() << '\n';
	std::cout << typeid(std::remove_const_t<T>).name() << '\n';
	std::cout << typeid(std::remove_pointer_t<T>).name() << '\n';

std::cout << typeid(T).name() << '\n';

std::cout << typeid(std::decay_t<T>).name() << '\n';

std::cout << typeid(std::remove_cv_t<T>).name() << '\n';

std::cout << typeid(std::remove_const_t<T>).name() << '\n';

std::cout << typeid(std::remove_pointer_t<T>).name() << '\n';

is_sameは渡された２つの型が同じならtrue。
decayは配列参照などをポインタにしてくれる。
remove_cvはconstやvolatileを除去
remove_pointerはポインタを１つ除去する。

_vで終わるのはvalue,is_same::valueなどと同じ。
_tで終わるのはtype,remove_cv::typeなどと同じ。

ソース：https://github.com/ambiesoft/blogprogs/tree/master/6006/ConsoleApplication1