Category Archives: C++

std::pairとstd::tieとstd::make_pairを使う。

#include <string>
#include <tuple>
#include <iostream>

std::pair<int, std::string> getValues()
{
	return std::make_pair(100, "abc");
}

int main()
{
	int i;
	std::string s;

	std::tie(i, s) = getValues();

	// outputs '100 abc'
	std::cout << i << " " << s << std::endl;
	return 0;
}

#include <string>

#include <tuple>

#include <iostream>

std::pair<int, std::string> getValues()

{

return std::make_pair(100, "abc");

}

int main()

{

int i;

std::string s;

std::tie(i, s) = getValues();

// outputs '100 abc'

std::cout << i << " " << s << std::endl;

return 0;

}

C言語の標準ライブラリで文字コードの変換

2021年7月23日

admin

C++ No Comments

Visual Studioだけで試した。自分用に貼っておく。

char szA[32];
wchar_t szW[32];
{
	// 普通は日本語を直接こう書いてはいけない
	// 日本語環境のWindowsをつかっているとソースコードの文字コードに関わらず
	// pはcp932になる
	// 英語環境の場合はpには文字化けした文字しか入らない
	// char p[] = "あいうえお";
	// "あいうえお"のcp932での値列
	char p[] = { 0x82, 0xa0, 0x82, 0xa2, 0x82, 0xa4, 0x82, 0xa6, 0x82, 0xa8, 0x00 };
	
	// これを書かないと動かない
	// 第2引数""はユーザの環境でロケールを初期化することを意味する
	// setlocale(LC_ALL, "");  // 日本語Windowsの場合はこれでも大体動く
	setlocale(LC_ALL, ".932");  // 日本語じゃないWindowsの場合でも動く
	

	size_t converted = 0;
	int ret = mbstowcs_s(&converted, szW, p, _countof(szW) - 1);
	assert(ret == 0);
	
	// もとに戻す
	ret = wcstombs_s(&converted, szA, szW, _countof(szA) - 1);
	assert(ret == 0);
	assert(strcmp(p, szA) == 0);
}

{
	// こう書くのはセーフ
	// ただしソースコードをutf8で保存すること
	char p[] = u8"あいうえお";
	
	// これを書かないと動かない
	// 第2引数はUTF8でロケールを初期化することを意味する
	setlocale(LC_ALL, ".UTF8");
	
	size_t converted = 0;
	int ret = mbstowcs_s(&converted, szW, p, _countof(szW) - 1);
	assert(ret == 0);

	// もとに戻す
	ret = wcstombs_s(&converted, szA, szW, _countof(szA) - 1);
	assert(ret == 0);
	assert(strcmp(p, szA) == 0);
}

char szA[32];

wchar_t szW[32];

{

// 普通は日本語を直接こう書いてはいけない

// 日本語環境のWindowsをつかっているとソースコードの文字コードに関わらず

// pはcp932になる

// 英語環境の場合はpには文字化けした文字しか入らない

// char p[] = "あいうえお";

// "あいうえお"のcp932での値列

char p[] = { 0x82, 0xa0, 0x82, 0xa2, 0x82, 0xa4, 0x82, 0xa6, 0x82, 0xa8, 0x00 };

// これを書かないと動かない

// 第2引数""はユーザの環境でロケールを初期化することを意味する

// setlocale(LC_ALL, ""); // 日本語Windowsの場合はこれでも大体動く

setlocale(LC_ALL, ".932"); // 日本語じゃないWindowsの場合でも動く

size_t converted = 0;

int ret = mbstowcs_s(&converted, szW, p, _countof(szW) - 1);

assert(ret == 0);

// もとに戻す

ret = wcstombs_s(&converted, szA, szW, _countof(szA) - 1);

assert(ret == 0);

assert(strcmp(p, szA) == 0);

}

{

// こう書くのはセーフ

// ただしソースコードをutf8で保存すること

char p[] = u8"あいうえお";

// これを書かないと動かない

// 第2引数はUTF8でロケールを初期化することを意味する

setlocale(LC_ALL, ".UTF8");

size_t converted = 0;

int ret = mbstowcs_s(&converted, szW, p, _countof(szW) - 1);

assert(ret == 0);

// もとに戻す

ret = wcstombs_s(&converted, szA, szW, _countof(szA) - 1);

assert(ret == 0);

assert(strcmp(p, szA) == 0);

}

C言語とC++のlocale

2021年7月23日

admin

C++ No Comments

localeの基本

日付の表示方法は国によって違う。アメリカなら’Friday, July 23, 2021’みたいになり、日本なら’2021/7/23’みたいになる。ほかにも、数字のカンマやピリオドのつけ方や金額表示の仕方もちがう。このような違いを扱うのがlocaleという概念。

char *setlocale(
   int category,
   const char *locale
);

char *setlocale(

int category,

const char *locale

);

catergoryには時刻を扱う。LC_TIMEなどいろいろあるが、ここでは一括で扱うLC_ALLを基本的に考える。

locale文字列は国・地域・言語を表す文字列で、”en-US”などと指定するがプログラム開始時には”C”になっており、”C”は１文字１charであることを意味している。”en-US”などの場合は言語と地域を表しており、さらに追加して”en-US.UTF8″などとも書ける。localeにNULLを渡すと現在の値を取得する。localeに空文字を渡すとユーザのデフォルトの国や地域そしてコードページが指定される。

printf("Current locale is '%s'\n", setlocale(LC_ALL, NULL));
printf("Locale for empty is '%s'\b", setlocale(LC_ALL, ""));

1 2	printf("Current locale is '%s'\n", setlocale(LC_ALL, NULL)); printf("Locale for empty is '%s'\b", setlocale(LC_ALL, ""));

これを英語のWindowsで実行すると以下のように出力される。

Current locale is 'C'
Locale for empty is 'English_United States.1252'

1 2	Current locale is 'C' Locale for empty is 'English_United States.1252'

Englishが言語で、United Statesが国・地域、1252がコードページを表しこれは’en-US.1252″と同じ意味だろう。

localeに”.UTF8″とするとコードページだけ変えることができる。ここで指定したコードページはmbtowcsなどでワイド文字列に変換するときに使われる。

wchar_t szW[32];
{
    setlocale(LC_ALL, ".1252");
    char p[] = "あ";
    // 文字化け、コードページ1252(latin1)に'あ'はない
    // ここの"あ"はソースコードの文字コードがどうであろうとANSIと解釈されるはず
    // つまり英語環境のWindowsではpはそもそも文字化けしている。
    mbtowc(szW, p, strlen(p));
}
{
    setlocale(LC_ALL, ".UTF8");
    char p[] = u8"あ";
    // pはUTF8
    // ちゃんと変換できる。
    mbtowc(szW, p, strlen(p));
}

wchar_t szW[32];

{

setlocale(LC_ALL, ".1252");

char p[] = "あ";

// 文字化け、コードページ1252(latin1)に'あ'はない

// ここの"あ"はソースコードの文字コードがどうであろうとANSIと解釈されるはず

// つまり英語環境のWindowsではpはそもそも文字化けしている。

mbtowc(szW, p, strlen(p));

}

{

setlocale(LC_ALL, ".UTF8");

char p[] = u8"あ";

// pはUTF8

// ちゃんと変換できる。

mbtowc(szW, p, strlen(p));

}

C++の場合

上記の話はC言語の話だった。C言語ではlocaleは１つしかなく、グローバル設定があるだけだったが、C++ではlocaleはクラスになった。

C言語との関係

stdにもstd::setlocale()があり、これは上記と同じようにグローバルなlocaleを設定するものだろう。

localeクラス

C++ではcategoryの代わりにFacetと言うようになった。
C言語ではsetlocal()で設定した情報はグローバルでどこかに格納されそれがアプリコードからは見えないところで参照されるが、C++のストリームでは明示的にlocaleクラスを設定しなければならない

コンストラクタ―

引数のないコンストラクタstd::locale()は、グローバルlocaleクラスのコピーを作成する。

文字列を指定

std::locale("ja-JP")は”ja-JP”のlocaleクラスを作成する。作成しただけではどこにも反映されない。

std::locale::classic();

これはsetlocal(LC_ALL, "C")と同じlocaleのインスタンス参照をかえす。

グローバルに設定

staticなstd::locale::global(locale& l)を呼ぶと、locale lをグローバルに設定する。

ストリームに設定

C++方式でグローバルに設定したlocaleはC言語の関数には影響を与えるがストリームには影響しない。ストリームに反映させるにはimbue()を使って設定する。

{
    std::locale loc("en-US");
    std::wcout.imbue(loc);
    std::wcout << loc.name().c_str() << " " << d << '\n';
}
{
    std::locale loc("ja-JP");
    std::wcout.imbue(loc);
    std::wcout << loc.name().c_str() << " " << d << '\n';
}
{
    std::locale loc("de-DE");
    std::wcout.imbue(loc);
    std::wcout << loc.name().c_str() << " " << d << '\n';
}

{

std::locale loc("en-US");

std::wcout.imbue(loc);

std::wcout << loc.name().c_str() << " " << d << '\n';

}

{

std::locale loc("ja-JP");

std::wcout.imbue(loc);

std::wcout << loc.name().c_str() << " " << d << '\n';

}

{

std::locale loc("de-DE");

std::wcout.imbue(loc);

std::wcout << loc.name().c_str() << " " << d << '\n';

}

en-US 1,234.56
ja-JP 1,234.56
de-DE 1.234,56

en-US 1,234.56

ja-JP 1,234.56

de-DE 1.234,56

Facetとstd::codecvt

省略、facetはbasic_stringのtraitsのように自分で作ることができる、codecvtもfacetの一つ、これは非推奨でなおかつlocaleを使いにくい。globalなlocaleも反映されない。

式の中に出てくるtypenameやtemplate

2021年7月21日

admin

C++ No Comments

これらのキーワードは次のトークンがタイプなのかテンプレートなのかを指定する。テンプレート関数内でテンプレート引数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

C++でリテラルの文字列をLのリテラルにしてつなげる

2021年7月3日

admin

C++ No Comments

前提

Cのリテラル文字列は２つ続けて書くと連結してくれる。

	const char* p = "abc" "xyz";
	// p is "abcxyz"

#define ABC "abc"
#define XYZ "xyz"
	const char* q = ABC XYZ;
	// q is "abcxyz"

const char* p = "abc" "xyz";

// p is "abcxyz"

#define ABC "abc"

#define XYZ "xyz"

const char* q = ABC XYZ;

// q is "abcxyz"

マクロ

ここでL”abcxyz”がほしいときは以下のようにする。

#define TO_LSTRINNER(x) L ## x
#define TO_LSTR(x) TO_LSTRINNER(x)

const wchar_t* wp = TO_LSTR(ABC) TO_LSTR(XYZ);

#define TO_LSTRINNER(x) L ## x

#define TO_LSTR(x) TO_LSTRINNER(x)

const wchar_t* wp = TO_LSTR(ABC) TO_LSTR(XYZ);

２重のマクロにしないとならない。１重にすると以下のように解釈される

const wchar_t* wp = TO_LSTRINNER(ABC);

1	const wchar_t* wp = TO_LSTRINNER(ABC);

これは以下のように展開される。

	const wchar_t* wp = LABC;

1	const wchar_t* wp = LABC;

つまりマクロを一回かますと、マクロが展開されることになる。##は連結するがシンボルとかを意識しないので単に結びつける、マクロを一回かまさないと展開されないのでLABCになってしまう。このLABCがどこかで#defineされていればちゃんと展開される。

#

ちなみにマクロの#は文字列にして展開してくれるので以下のように書くこともできる。もっと良い書き方があるのかよくわからない。

#define ABC abc
#define XYZ xyz

#define TO_STRINNER(x) #x
#define TO_STR(x) TO_STRINNER(x)

#define TO_LSTRINNERINNER(x) L ## x
#define TO_LSTRINNER(x) TO_LSTRINNERINNER(#x)
#define TO_LSTR(x) TO_LSTRINNER(x)

#endif

int main()
{
	const char* q = TO_STR(ABC) TO_STR(XYZ);
	// q is "abcxyz"

	const wchar_t* wp = TO_LSTR(ABC) TO_LSTR(XYZ);
	// wp is L"abc" L"xyz";
}

#define ABC abc

#define XYZ xyz

#define TO_STRINNER(x) #x

#define TO_STR(x) TO_STRINNER(x)

#define TO_LSTRINNERINNER(x) L ## x

#define TO_LSTRINNER(x) TO_LSTRINNERINNER(#x)

#define TO_LSTR(x) TO_LSTRINNER(x)

#endif

int main()

{

const char* q = TO_STR(ABC) TO_STR(XYZ);

// q is "abcxyz"

const wchar_t* wp = TO_LSTR(ABC) TO_LSTR(XYZ);

// wp is L"abc" L"xyz";

}

ソース

https://github.com/ambiesoft/blogprogs/tree/master/5910/literalmacro

コンパイルに/Pオプションを付けるとマクロの展開した時点のソースを拡張子.iをつけて出力してくれる。

アプリがクラッシュしたときクラッシュダンプを作成する

レジストリへ登録

レジストリキーHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps\iwillcrash.exe以下にダンプ情報を作成する。

これはレポジトリにあるcreatecrashdump.regを実行することで作成できる。

クラッシュさせる

iwillcrash.exeを実行して、「Access Null Pointer」をクリックするとアプリが落ちて、%LOCALAPPDATA%\CrashDumpsにダンプファイルが作成される。

任意のアプリの登録

上記の実例ではiwillcrash.exeというファイルのアプリのみのダンプをとるので、レジストリキーのiwillcrash.exeのキー名を対象アプリのファイル名に変えれば任意のアプリのダンプをとることができる。

参考情報

Registry:HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CrashControl