std::pairとstd::tieとstd::make_pairを使う。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#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; } |
Visual Studioだけで試した。自分用に貼っておく。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
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); } |
日付の表示方法は国によって違う。アメリカなら’Friday, July 23, 2021’みたいになり、日本なら’2021/7/23’みたいになる。ほかにも、数字のカンマやピリオドのつけ方や金額表示の仕方もちがう。このような違いを扱うのがlocaleという概念。
|
1 2 3 4 |
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に空文字を渡すとユーザのデフォルトの国や地域そしてコードページが指定される。
|
1 2 |
printf("Current locale is '%s'\n", setlocale(LC_ALL, NULL)); printf("Locale for empty is '%s'\b", setlocale(LC_ALL, "")); |
これを英語のWindowsで実行すると以下のように出力される。
|
1 2 |
Current locale is 'C' Locale for empty is 'English_United States.1252' |
Englishが言語で、United Statesが国・地域、1252がコードページを表しこれは’en-US.1252″と同じ意味だろう。
localeに”.UTF8″とするとコードページだけ変えることができる。ここで指定したコードページはmbtowcsなどでワイド文字列に変換するときに使われる。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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言語ではlocaleは１つしかなく、グローバル設定があるだけだったが、C++ではlocaleはクラスになった。
stdにもstd::setlocale()があり、これは上記と同じようにグローバルなlocaleを設定するものだろう。
引数のないコンストラクタstd::locale()は、グローバルlocaleクラスのコピーを作成する。
std::locale("ja-JP")は”ja-JP”のlocaleクラスを作成する。作成しただけではどこにも反映されない。
これはsetlocal(LC_ALL, "C")と同じlocaleのインスタンス参照をかえす。
staticなstd::locale::global(locale& l)を呼ぶと、locale lをグローバルに設定する。
C++方式でグローバルに設定したlocaleはC言語の関数には影響を与えるがストリームには影響しない。ストリームに反映させるにはimbue()を使って設定する。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
{ 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'; } |
|
1 2 3 |
en-US 1,234.56 ja-JP 1,234.56 de-DE 1.234,56 |
省略、facetはbasic_stringのtraitsのように自分で作ることができる、codecvtもfacetの一つ、これは非推奨でなおかつlocaleを使いにくい。globalなlocaleも反映されない。
これらのキーワードは次のトークンがタイプなのかテンプレートなのかを指定する。テンプレート関数内でテンプレート引数Tに依存するトークンが出てきたとき、コンパイラはそのトークンがタイプなのかテンプレートなのか関数なのか変数なのかわからない。
|
1 |
T::A<0>(x); |
Aが変数なら、例えば0に置き換えてみると以下のようになる。
|
1 |
0<0>(x); |
<や>は小なりと大なりと解釈され、有効な式になる。
Aが関数の場合は<0>はテンプレート引数となりxを引数とする関数コールになる。
Aがテンプレートクラスの場合はそのクラスインスタンスxの定義になる。
テンプレートが実体化されたときにわかりそうだが、意図した動作と違う時にエラーの発見が難しくもなりそうなので、Tに依存するトークンでそれがあいまいな場合（どんな時あいまいなのかはよくわからない）はtypenameやtemplateといったキーワードをつける約束になっているようだ。この例の場合はAはintなどの基本タイプにはなれない。
このような用途で使うのがtypenameとtemplate。
T::Aがタイプの場合に指定する。これはよく使う。意味不明なエラーが出た場合につけると直ることが多い。
カギカッコなしのtemplateは他の使い方もあるが、ここではTに依存する（Tの中にある）テンプレートクラスやテンプレート関数を指定するときにつけるようだ。テンプレートクラスの場合はタイプでもあるので、両方つけることもある。
|
1 |
typename T::template A<0>(x); |
こういうものをつけなければならないときはusingを使って別名にしておいた方がいいだろう。
typenanmeもtemplateもつけてはいけない（つけるとエラー）
typenameとtemplateと両方つけるか、何もつけない（typenameだけだとエラー）
両方つけないとエラー
https://github.com/ambiesoft/blogprogs/tree/master/6151/templatetypename
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
#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はintなどを文字列にして返す標準ライブラリ関数。便利なのだが、charとwchar_tで分かれているので汎用コードを書きたいときにそのまま書きたくない。Windowsはもはやwchar_tが主流だしLinuxではcharが主流でwchar_tは４バイトになることが多い。よってこれらをそのまま使うと汎用性がなくなる。
これらの関数をテンプレート関数にしたいとき、テンプレート引数は２つになり、最初の引数はcharかwchar_t、次の引数はintやdoubleとなる。テンプレート関数は部分特殊化ができないので、これらの組み合わせすべて書くしかなくなって効率が悪い。
テンプレートクラスは部分特殊化ができるので、これを利用して汎用関数をつくりたい。文字列クラスのデフォルトをWindowsならwchar_tとしそれ以外ならcharとして扱えば同じ関数記述にできる。
|
1 2 3 4 5 |
template<typename C, typename T> struct class_stdToString { static_assert(sizeof(T) == 0, "char or wchar_t"); }; |
これは実体化されることを想定してないので、static_assert常に失敗。
次にcharの部分特殊化
|
1 2 3 4 5 6 7 8 |
template<typename T> struct class_stdToString<char, T> { static std::basic_string<char> call(const T& t) { return std::to_string(t); } }; |
同様にwchar_t
|
1 2 3 4 5 6 7 8 |
template<typename T> struct class_stdToString<wchar_t, T> { static std::basic_string<wchar_t> call(const T& t) { return std::to_wstring(t); } }; |
ここまではユーザは意識しないコード。次がユーザが呼ぶ関数。
|
1 2 3 4 5 |
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。
テストコード
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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()); } |
to_stringにはboolがなく、intとして解釈されるようなのでboolも完全特殊化で定義
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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などに変える関数は引数に文字列しか入らないので型の推論ができないのでそれぞれの型ごとに別関数にするしかないものと思われる。
まだ完全にはわからない
std::vector<T>などのTに何でも入れられることを前提にしてつくられているクラスはヘッダに書くしかないと思う。
この場合はソースファイルにかける。
ここでは文字列の長さをを返す関数でchar*とwchar_t*をとるGetStringLength()を考える。
|
1 2 3 4 5 6 7 8 9 10 |
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でどこかにそれがあることを示している。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#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); |
最初の２つは特殊化の定義。
次の２つは特殊化が定義されるときここに実体化されることを意味する。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#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の方に実装を書くこともできる。その場合にこのテンプレートを使うこともできる。
|
1 2 3 4 |
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); |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
#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); |
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#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は実装を実体化し外部に公開して他のソース・ファイルから見えるようにしているのだと思われる。
鉤括弧ありのテンプレートはあくまでコンパイルフェーズで解決するものであり、宣言だけのテンプレートを実体化しても宣言だけになり、それがリンクされることもないのだと思われる。
is_class<T>を使うとTがクラス（構造体含む）かどうか判定してくれる。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
#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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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がポインタだとエラーになる。
|
1 2 3 4 5 6 7 8 9 10 11 |
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などの挙動がいまいちよくわからないのでこの書き方であっているのか不明。以下のようなコードで実行時の型を表示してくれる。
|
1 2 3 4 5 |
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のリテラル文字列は２つ続けて書くと連結してくれる。
|
1 2 3 4 5 6 7 |
const char* p = "abc" "xyz"; // p is "abcxyz" #define ABC "abc" #define XYZ "xyz" const char* q = ABC XYZ; // q is "abcxyz" |
ここでL”abcxyz”がほしいときは以下のようにする。
|
1 2 3 4 |
#define TO_LSTRINNER(x) L ## x #define TO_LSTR(x) TO_LSTRINNER(x) const wchar_t* wp = TO_LSTR(ABC) TO_LSTR(XYZ); |
２重のマクロにしないとならない。１重にすると以下のように解釈される
|
1 |
const wchar_t* wp = TO_LSTRINNER(ABC); |
これは以下のように展開される。
|
1 |
const wchar_t* wp = LABC; |
つまりマクロを一回かますと、マクロが展開されることになる。##は連結するがシンボルとかを意識しないので単に結びつける、マクロを一回かまさないと展開されないのでLABCになってしまう。このLABCがどこかで#defineされていればちゃんと展開される。
ちなみにマクロの#は文字列にして展開してくれるので以下のように書くこともできる。もっと良い書き方があるのかよくわからない。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#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
