Tag Archives: C++

前提

まだ完全にはわからない

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);

最初のテンプレート関数は汎用の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);

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

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

}

今回の場合は実装がほぼないのでテンプレートにする意味があんまりないが、２つの実装がほぼ同じで、一部だけ書き換えたいときは汎用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);

ソース＆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 <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);

}

テンプレート関数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);

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...);

}

最初の引数の型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';

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#のRichTextBoxのフォントが途中で変わる

2021年6月21日

admin

C# No Comments

RichTextBoxのIMF_DUALFONTとIMF_AUTOFONTフラグをクリアする。デフォルトでオンになっている。

uint lParam;

lParam = SendMessage(richTextBoxMessage.Handle, EM_GETLANGOPTIONS, 0, 0);

lParam &= ~(IMF_DUALFONT | IMF_AUTOFONT);

SendMessage(richTextBoxMessage.Handle, EM_SETLANGOPTIONS, 0, lParam);

private const uint IMF_AUTOFONT = 0x02;

private const uint IMF_DUALFONT = 0x80;

private const uint WM_USER = 0x0400;

private const uint EM_SETLANGOPTIONS = WM_USER + 120;

private const uint EM_GETLANGOPTIONS = WM_USER + 121;

[System.Runtime.InteropServices.DllImport("USER32.dll")]

private static extern uint SendMessage(System.IntPtr hWnd, uint msg, uint wParam, uint lParam);

参考：http://pineplanter.moo.jp/non-it-salaryman/2017/11/25/post-5255/

emplace_backでムーブコンストラクタがあるのにコピーコンストラクタが呼ばれる

2021年5月9日

admin

C++ No Comments

puch_backよりもemplace_backがいいと言われていて実験したら、push_backだとコピーコンストラクタが呼ばれないのに、emplace_backだと呼ばれる現象が発生。

結論

ムーブコンストラクタにnoexceptをつければコピーコンストラクタの代わりにムーブコンストラクタが呼ばれる。

#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <iostream>

class MyKlass {
	int ii_;
	float ff_;
	std::string ss_;
public:
	MyKlass(int ii, float ff, const std::string& ss) :
		ii_(ii), ff_(ff), ss_(ss) {
		std::cout << "ctor" << std::endl;
	}
	MyKlass(const MyKlass& that) :
		ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {
		std::cout << "copy" << std::endl;
	}
	MyKlass(MyKlass&& that) :
		ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {
		std::cout << "move" << std::endl;
	}

~MyKlass() {
		std::cout << "dtor" << std::endl;
	}
};

// just add 'noexcept' to move ctor
class MyKlassWithNoExcept {
	int ii_;
	float ff_;
	std::string ss_;
public:
	MyKlassWithNoExcept(int ii, float ff, const std::string& ss) :
		ii_(ii), ff_(ff), ss_(ss) {
		std::cout << "ctor" << std::endl;
	}
	MyKlassWithNoExcept(const MyKlassWithNoExcept& that) :
		ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {
		std::cout << "copy" << std::endl;
	}
	MyKlassWithNoExcept(MyKlassWithNoExcept&& that) noexcept :
		ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {
		std::cout << "move" << std::endl;
	}

~MyKlassWithNoExcept() {
		std::cout << "dtor" << std::endl;
	}
};

int main()
{
	// without noexcept
	{
		{
			std::vector<MyKlass> v;
			v.emplace_back(2, 3.14f, "jio");  // ctor
			std::cout << "---" << std::endl;
			
			v.emplace_back(2, 3.14f, "jio");  // ctor, copy, dtor
			std::cout << "---" << std::endl;
			
			v.emplace_back(2, 3.14f, "jio");  // ctor, copy, copy, dtor, dtor
			std::cout << "---" << std::endl;
		}

std::cout << "------------------" << std::endl;

{
			std::vector<MyKlass> v;
			v.push_back(MyKlass(2, 3.14f, "jij"));  // ctor, move, dtor
			std::cout << "---" << std::endl;

v.push_back(MyKlass(2, 3.14f, "jij"));  // ctor, move, copy, dtor, dtor
			std::cout << "---" << std::endl;
			
			v.push_back(MyKlass(2, 3.14f, "jij"));  // ctor, move, copy, copy, dtor, dtor, dtor
			std::cout << "---" << std::endl;
		}

std::cout << "------------------" << std::endl;
	}

// with noexcept
	{
		{
			std::vector<MyKlassWithNoExcept> v;
			v.emplace_back(2, 3.14f, "jio");  // ctor
			std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio");  // ctor, move, dtor
			std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio");  // ctor, move, move, dtor, dtor
			std::cout << "---" << std::endl;
		}

std::cout << "------------------" << std::endl;

{
			std::vector<MyKlassWithNoExcept> v;
			v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij"));  // ctor, move, dtor
			std::cout << "---" << std::endl;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij"));  // ctor, move, move, dtor, dtor
			std::cout << "---" << std::endl;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij"));  // ctor, move, move, move, dtor, dtor, dtor
			std::cout << "---" << std::endl;
		}

std::cout << "------------------" << std::endl;
	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

#include <iostream>

#include <vector>

#include <string>

#include <cassert>

#include <iostream>

class MyKlass {

int ii_;

float ff_;

std::string ss_;

public:

MyKlass(int ii, float ff, const std::string& ss) :

ii_(ii), ff_(ff), ss_(ss) {

std::cout << "ctor" << std::endl;

}

MyKlass(const MyKlass& that) :

ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {

std::cout << "copy" << std::endl;

}

MyKlass(MyKlass&& that) :

ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {

std::cout << "move" << std::endl;

}

~MyKlass() {

std::cout << "dtor" << std::endl;

}

};

// just add 'noexcept' to move ctor

class MyKlassWithNoExcept {

int ii_;

float ff_;

std::string ss_;

public:

MyKlassWithNoExcept(int ii, float ff, const std::string& ss) :

ii_(ii), ff_(ff), ss_(ss) {

std::cout << "ctor" << std::endl;

}

MyKlassWithNoExcept(const MyKlassWithNoExcept& that) :

ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {

std::cout << "copy" << std::endl;

}

MyKlassWithNoExcept(MyKlassWithNoExcept&& that) noexcept :

ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {

std::cout << "move" << std::endl;

}

~MyKlassWithNoExcept() {

std::cout << "dtor" << std::endl;

}

};

int main()

{

// without noexcept

{

std::vector<MyKlass> v;

v.emplace_back(2, 3.14f, "jio"); // ctor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, copy, dtor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, copy, copy, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

{

std::vector<MyKlass> v;

v.push_back(MyKlass(2, 3.14f, "jij")); // ctor, move, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlass(2, 3.14f, "jij")); // ctor, move, copy, dtor, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlass(2, 3.14f, "jij")); // ctor, move, copy, copy, dtor, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

}

// with noexcept

{

std::vector<MyKlassWithNoExcept> v;

v.emplace_back(2, 3.14f, "jio"); // ctor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, move, dtor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, move, move, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

{

std::vector<MyKlassWithNoExcept> v;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij")); // ctor, move, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij")); // ctor, move, move, dtor, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij")); // ctor, move, move, move, dtor, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

}

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

C#のOpenFileDialogで拡張子exeの実行ファイルをフィルタして選択

2020年12月30日

admin

C# No Comments

private void btnBrowseApp_Click(object sender, EventArgs e)

{

using (OpenFileDialog dlg = new OpenFileDialog())

{

dlg.Title = "title";

dlg.DefaultExt = "exe";

StringBuilder sbFilter = new StringBuilder();

sbFilter.Append("Application");

sbFilter.Append(" ");

sbFilter.Append("(*");

sbFilter.Append(".exe");

sbFilter.Append(")|*");

sbFilter.Append(".exe");

sbFilter.Append("|");

sbFilter.Append("All Files (*.*)|*.*");

dlg.Filter = sbFilter.ToString();

if (DialogResult.OK != dlg.ShowDialog())

return;

txtApp.Text = dlg.FileName;

}

C#とjavascriptの時間

2020年11月21日

admin

C# javascript No Comments

基本

時間を表す言葉には時刻と時間間隔があるので時間という言葉ではあいまいになる。
どちらの場合も単位と基準点が問題になる。単位は秒とかミリ秒とかのこと、基準はUTCとか日本時間のこと。

Unix time stamp

UTCで1970/1/1からの秒を表す。今の値はこことかでわかる。

C#でこの値を得るには以下のコード

1	Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;

C#のDateTimeは0001/1/1からの100ナノ秒で管理しているようだ。３つの引数をとるコンストラクタはグレゴリオカレンダーで初期化するのでこれでいいらしい。

javscriptでこの値を得るには以下のコード

1	var ts = Math.round((new Date()).getTime() / 1000);

javascriptのDateはUTCで1970/1/1からのミリ秒で管理しているようだ。デフォルトのコンストラクタは今でgetTime()はミリ秒でUnix Epoch(=Unix time stamp)を返すので1000で割って秒にしている。

Unix time stampからオブジェクトをつくる

C#の場合は以下のようにやるらしい

public static DateTime UnixTimeStampToDateTime( double unixTimeStamp )

{

// Unix timestamp is seconds past epoch

System.DateTime dtDateTime = new DateTime(1970,1,1,0,0,0,0,System.DateTimeKind.Utc);

dtDateTime = dtDateTime.AddSeconds( unixTimeStamp ).ToLocalTime();

return dtDateTime;

}

これだとローカル時間が帰るので以下のように修正

public static DateTime UnixTimeStampToDateTime(double unixTimeStamp)

{

// Unix timestamp is seconds past epoch

System.DateTime dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);//, System.DateTimeKind.Utc);

dtDateTime = dtDateTime.AddSeconds(unixTimeStamp);//.ToLocalTime();

return dtDateTime;

}

javascriptの場合は以下

1	var date = new Date(UNIX_Timestamp * 1000);

ソースコード

https://github.com/ambiesoft/blogprogs/tree/master/5705

enable_if

2020年5月28日

admin

C++ 未分類 No Comments

enable_ifによりある条件のときだけtemplateを有効にすることができる。逆に言うとtemplateにしたくない条件を無効化することができる。

// 5-example.cpp : This file contains the 'main' function. Program execution begins and ends there.

#include <iostream>

template<typename T>

void myfunc(T t)

{

std::cout << t << "\n";

}

template<typename T,

typename = std::enable_if_t<std::is_convertible_v<T, int>>>

void myintfunc(T t)

{

}

template<typename T,

typename = std::enable_if<std::is_convertible<T, int>::value>::type>

void myintfunc_old(T t)

{

}

int main()

{

myfunc('a');

myfunc(10);

myfunc("hello");

myfunc(std::string("hello2"));

myintfunc('a');

myintfunc(10);

error C2672: 'myintfunc': no matching overloaded function found

error C2783: 'void myintfunc(T)': could not deduce template argument for '<unnamed-symbol>'

message : see declaration of 'myintfunc'

// myintfunc("hello");

myintfunc_old('a');

myintfunc_old(10);

// myintfunc_old("hello");

}

std::enable_if_t<std::is_convertible_v<T, int>>はstd::enable_if<std::is_convertible<T, int>::value>::type>と同じことなのでこれについて考える。

全体としての意味はTがintに変換できるときだけテンプレートを有効にするということ。

is_convertible<T, int>はTがintに変換できるかを判定し、その結果はvalueに格納される。

enable_if<A>はAがtrueかどうかを判定し、trueならばtypeに型voidを格納する。falseならエラーになる。

よって全体としてTがintに変換できない場合はエラーになり、templateのインスタンス化は行われない（コンパイルエラーにはならない（SFINAE））。

この例ではどういうときにこれを使うのかの応用例は示せていないが、特定の型のときだけテンプレートを有効にしたい場合に使う。

typename = としているのはtypename A = などと同じでデフォルトのテンプレート引数の指定、これはテンプレートのインスタンス化をするかどうかだけのために使われるので、コード中では使われないのでこういう記述になっている。

stringのvectorをスペースで区切って１つのstringにする

2019年12月22日

admin

C++ No Comments

TLTR

vector<string> vs = { "aaa", "bbb", "ccc" };

ostringstream oss;

std::copy(vs.begin(), vs.end(),

ostream_iterator<string>(oss, " "));

ostringstreamとは

<<で渡された値を内部に持っているstringに追加していく。

ostringstream oss;

oss << 1 ;

oss << 10 << "\n";

oss << 100 << "\n";

oss << "xxx" << "\n";

oss << "yyy" << "\n";

oss << "zzz" << "\n";

cout << oss.str() << endl;

ostream_iteratorとは

=で渡された値をコンストラクタで渡された出力ストリームに追加していく。
コンストラクタの２番めの引数はデリミタを指定する。=でストリームに追加したあとにこの値も追加する。デフォルトでは何も追加しない。
++演算では何もしない。これにより下記のcopyで役に立つ。

{

ostream_iterator<int> osi(cout, "\n");

osi = 1;

osi = 2;

osi = 3;

}

{

ostream_iterator<string> osi(cout, "\n");

osi = "osstest1";

osi = "osstest2";

osi = "osstest3";

}

上のコードは以下のようにコンソールに出力される。

osstest1

osstest2

osstest3

copyとは

第一引数と第二引数のイテレータで入力範囲を指定する。
第三引数で出力イテレータを指定する。

入力出力とも++で一個ずつずらしていって=でコピーする。

{

vector<int> vi = { 1, 2, 3 };

vector<int> vi2(3);

copy(vi.begin(), vi.end(),

vi2.begin());

}

{

vector<string> vs = { "a", "b", "c" };

vector<string> vs2(3);

copy(vs.begin(), vs.end(),

vs2.begin());

}

ostream_iteratorの++は何もしないで=で値をストリームに追加する。（最初のコード参照）