汎用な型を取れる配列の各要素に、同じ処理を実行したい。

Question

実現したいこと

複数の型を取れる配列の各要素に対し、その要素の型に依らず同じような処理を実行したい。

前提

言語はC++です。
下記の簡単なサンプルコードでは、複数の型のデータを一つの配列でまとめて、各要素に同じような処理を実行しています。
このコードでも問題はないのですが、test[i].typeの値で分岐しているところが冗長な気がします。
値のやりとりするとき毎回こんなキャストしなければいけないかとも思います。
long long 型にキャストして出力、というのは型に依らず同じ処理なので、一文にまとめられる上手い書き方があればいいな、というのが今回の質問です。
なお、今回void*には(unsigned )int, (unsigned )long long, charなどの数値型しか入らないとします。（キャスト不可な場合は考えない？）

該当のソースコード

//main.cpp

#include <iostream>
#include <vector>
#include <stack>


using namespace std;

class TEST{
public:
	void* val;
	int type;
};

int main(void) {
	int a = 1;
	char b = 'c';
	long long c = 10000;


	TEST test[3];
	test[0].val = &a;
	test[0].type = 0;
	test[1].val = &b;
	test[1].type = 1;
	test[2].val = &c;
	test[2].type = 2;
	
	for (int i = 0; i < 3; i++) {
		switch (test[i].type)
		{
		case 0:
			cout << (long long)*(int *)test[i].val << endl;
			break;
		case 1:
			cout << (long long)*(char *)test[i].val << endl;
			break;
		case 2:
			cout << (long long)*(long long *)test[i].val << endl;
			break;
		default:
			break;
		}
	}
}

試したこと

templateやanyなどで解決できそうな気もしましたが、やはりうまい方法が思い浮かびません。可能なら、その方法をご教示願います。

↓こんなのもありました。これなら実現できますが、上記のレベルでここまで大層なことをしないといけないでしょうか。
https://qiita.com/mm_sys/items/9afb811c2e0c67a5cfd5
（[C++] 異なる型を一つの配列で管理するクラス）

備考

あくまで知見を広めたい為の質問ですので、C++のバージョンなどの環境によって可能/不可能変わるような書き方でも是非教えて頂きたいです。
以上、宜しくお願い致します。

Comments

[fana]

あれ？　何か今，この質問にタグが一個もついてないですね．
（そういう修正がなされたようにも見えないし…？）

[do_a]

おかしいですね、確かに何もしていないのですが・・・？

[TN8001]

@fanaさん
> あれ？　何か今，この質問にタグが一個もついてないですね．

たまに起きているteratailのバグだと思います（リニューアル後に気づきましたがそれ以前からあったかどうかは不明）

今年に入ってからこのくらいはすでに発生しています。
https://teratail.com/questions/2sxv3octga2770
https://teratail.com/questions/l0qbfodpzk46r4
https://teratail.com/questions/svpmv6gg7o8qvq
https://teratail.com/questions/9wkvund7nlc9gw
https://teratail.com/questions/plxd4duhkuadl0
https://teratail.com/questions/00acicyty497bk

> （そういう修正がなされたようにも見えないし…？）

質問者がタグをすべて消すのってできないんですよね？（質問したことないのでわかりませんが^^;

なんとなくBAした時・自己回答した時等、質問者が何かアクションをした時に（何らかの条件を満たしてしまうと）タグが消えてる気がします。

閲覧側からするとかなりイヤなのですが、質問者は悪くないし（BA後は見てないだろうし）また付け直してもらう（おそらく普通にできるはず）のも気が引けるんですよね^^;

@do_aさん
> おかしいですね、確かに何もしていないのですが・・・？

よければ質問を編集して付け直してもらっていいですか？

[do_a]

> よければ質問を編集して付け直してもらっていいですか？

付け直せたんですね。対応いたしました。

[TN8001]

やっぱりできますね^^
わざわざすいませんでした。

[fana]

なんだバグかぁ．
タグで絞り込みかけてると，突然質問の一覧から消失するので「あれ？」ってなりますね．

Answer 1

とりえる型の種類が事前にわかっているなら C++17 以降では std::variant を使えます。

#include <iostream>
#include <variant>

int main(void) {
    int a = 1;
    char b = 'c';
    long long c = 10000;

    std::variant<int, char, long long> test[3] = {a, b, c};
    for (auto& e : test)
        std::cout << std::visit([](const auto& x) -> long long int { return x; }, e) << std::endl;
}

型を有限個の種類に限定するのではなく「long long へ型変換可能な型」などとするなら標準ライブラリが提供するものだけでは丁度良いものがないので自前で準備しないといけないでしょう。

Comments

[do_a]

御回答ありがとうございます。
variantですか！
少し調べてみましたが、visitor + lambdaですか、実行時の型で共通の処理を実行してくれるんですね。
勉強になります。

Answer 2

TEST 型はコンストラクタ引数の型を見てそこで long long への変換方法をメンバに保持しちゃえば良いのではないだろうか？
……とか思ったのですが，どうなんでしょう？

class TEST
{
private:
    using ToLLf = long long(*)( void * );
    void *val;
    ToLLf Cvt;  //long long への変換手段をメンバに覚えておく
    TEST( void *val, ToLLf Cvt ) : val(val), Cvt(Cvt) {}

    template<class VAL_T>
    static long long ToLL( void *val ){ return (long long)*(VAL_T*)val; }

public:
    //コンストラクタ引数の型に応じた変換手段をメンバに覚える
    template< class VAL_T >
    TEST( VAL_T *val ) : TEST( (void*)val, ToLL<VAL_T> ) {}

    //コンストラクタに与えたポインタが指す先の値を long long 型にキャストした結果を取得
    long long GetLL() const {   return Cvt(val);    }
};

//main
int main()
{
    int a = 1;
    char b = 'c';
    long long c = 10000;

    TEST test[3]{   TEST(&a), TEST(&b), TEST(&c)    };

    for( const auto &t : test )
    {   std::cout << t.GetLL() << std::endl;    }

    return 0;
}

Comments

[do_a]

ご回答ありがとうございます。
変換用のメンバ関数を宣言しておいて、インスタンス生成時にコンストラクタのタイミングで型を決めるていんですね！
個人的にとても新鮮なアイデアです。是非参考にさせてください。

ちなみに、知識不足で恐縮ですが、これってtestの要素数が増えるとその数だけ毎回ToLLを新しく定義するんでしょうか？（感覚的に、インスタンスの生成数だけToLLfに毎回GetLLをnewしているイメージ？）
テンプレートの仕様を理解しきれていなくて...。なんとなくメモリのコストとかどうなっているんだろうと気になりました。

もしよろしければ、教えて頂けると幸いです。

[do_a]

追記・訂正
>> （感覚的に、インスタンスの生成数だけToLLfに毎回GetLLをnewしているイメージ？）
　→（感覚的に、インスタンスの生成数だけCvtに毎回ToLLをnewしているイメージ？）
と聞きたかったです。

また、デバッグモードで見ると、test[i].Cvtの参照先のアドレスが違っていたので、ToLLはインスタンス毎に生成されていますね。
● これだと、ToLLの処理が長くなるほどメモリコストって大きくなるんでしょうか？
● また、ToLL は staticじゃないとエラーになりましたが、これってどうしてでしたっけ？
可能であれば、教えて頂けると幸いです。
宜しくお願い致します。

[fana]

> これってtestの要素数が増えるとその数だけ毎回ToLLを新しく定義するんでしょうか？

template というのは，「なんつーかさ，こういうコードを書いて欲しいんだよね．必要なときに」というコンパイラへの指示というかそんなイメージです．

この回答のコードの場合，TEST型インスタンスの個数は関係無くて，実際に使う型（：intとかcharとか）の種類分だけコンパイラ様が（前記の指示に従った形で）関数の定義を書いてくれる感じです．

例えば，インスタンスを何個作ってもその全員が引数に char* 型をとるコンストラクタで構築されるコードを書いたならば，必要なのは ToLL<char> だけなので，これだけが定義されることになります．
誰か一人でも int* ならば，int版も必要になるので ToLL<int> も定義されます．

templateを使わずに私が最初から頑張って書くとしたら

long long CharToLL( char * );
long long IntToLL( int * );
...(他にも必要な型のがあればその分だけ）

という複数種類の関数のコードを書かなきゃならないところを，コンパイラ様が代わりにやってくれるということですね．

[do_a]

すごい！
確かに今調べていたんですが、変数aとcの型を試しに両方intにした場合、test[0].Cvtとtest[2].Cvtの参照先アドレスが一緒になってました！
コンパイラ様賢いですね。
これなら全然問題なさそうです。
とても勉強になりました。ありがとうございました！

[fana]

うお？　コメントが変わった模様．

> ToLLはstaticなので、インスタンスの数に関わらず定義は一回ですね。

（static かどうかに限らず）同じメソッドとか関数の定義が複数になることは無いハズです．変数じゃないので．

> インスタンス毎の消費メモリはCvtの分で済む？

そうですね．TEST型インスタンスが保持するデータ（：メンバ変数）というのは val と Cvt の２つのポインタだけです．仮に両ポインタのサイズが64bitだとしたら，「１インスタンスあたり128bitのサイズ」みたいな感じになると思います．

> ToLL は staticじゃないとエラーになりましたが、これってどうしてでしたっけ？

これは単に私が

ToLLf Cvt; //Cvt の型というのは ToLLf
using ToLLf = long long(*)( void * ); // TolLLf というのはこういう形の関数ポインタ

という形で型を書いているからです．
ToLLf というのは「引数が void* で戻り値が long long な **(ふつうの)関数** を指すポインタ」なので，「引数がvoid* で戻り値が long long な **(staticじゃない)メソッド** を指すポインタ」とは型が違います．
関数ポインタ　と　メンバ関数ポインタ　に関して検索するとかすればその辺の話は見つかるかと思います．（メソッドはどのインスタンスについて呼ぶのか？という情報が必要だから実際には引数が１個多い的な雰囲気の話）

[do_a]

>> メソッドはどのインスタンスについて呼ぶのか？という情報が必要だから実際には引数が１個多い的な雰囲気の話

分かりやすいご説明ありがとうございます。
● static long long ToLL( void *val ) は、テンプレートにより必要な型のバージョン数だけ作られることになる（コンパイラによりオート）
● コンストラクタで ToLL<VAL_T> を引数に取った時に、対応する型バージョンのToLL()関数のアドレスが渡される
● 同じ関数が複数回定義されることはないので、ToLL()関数はオーバーロードの数だけしか存在しない
上記3点、理解しました。お付き合い頂きありがとうございました。

[fana]

どうでもいい話：template に関しての個人的な感覚というか．

例えば私の上司みたいな立場の人が「ここにchar型のデータを処理する関数があるじゃん？　このコードをコピペで増やしてint用とlong long用と unsigned short用のやつ作っといて．中身の処理は全く同じでデータの型が違うだけだから．ヨロ．」とか言ってきたら「え？　そんな力業で？　もっと他にやり方無いのか？」とか思う気がするんだけど，
template 書くって，これと全く同じ話を私がコンパイラに言ってるだけなんですよね．「これコピペで増やして対応よろしく^^」って．
なんかスマート感(?)みたいなのが無いよなぁ，みたいな？　（まぁ結局他に手が無いならば仕方ないのだけど）

[SaitoAtsushi]

言語仕様上の用語で言えば実体化 (instantiation) です。
関数テンプレートは実体化の工程を経て関数になります。
関連する規則は複雑で、簡単に説明できるようなものではないので「実体化」について適当な資料を探してみるのがよろしいかと思います。

[do_a]

みなさんありがとうございます！

[dameo]

質問者様へ

C++11以降はおろか、C++03、などかなり古いC++や、テンプレートを除けばCでも同じように書けそうです。ただこの回答を望んでいたのであれば、C++仕様バージョンを明記した方が良かったかもしれません。

※型を別の場所で自由に追加可能である点など、他の方法に対して優位性はあると思います

Answer 3

なお、今回void*には(unsigned )int, (unsigned )long long, charなどの数値型しか入らないとします。（キャスト不可な場合は考えない？）

std::tuple() を使うなど。

#include <iostream>
#include <tuple>

using namespace std;

int main(void) {
  int a = 1;
  char b = 'c';
  long long c = 10000;

  tuple test{a, b, c};

  apply([](auto&&... i) {
    ((cout << (long long)i << endl), ...);
  }, test);
}

Comments

[do_a]

ご回答ありがとうございます。
こんな方法もあるんですね。
色々な角度から解決策が見つかり、とても参考になります。

[dameo]

C++17以降ですね。配列でないと書いておいた方がいいかも。

Answer 4

typeがある以上どうしても実行時に条件分岐は必要になりますね。TESTクラスにメソッドを付けてその中で type による分岐をするのがシンプルな策ではないでしょうか。

std::variant を使うと条件分岐を隠すことはできます。

template <typename T> class Holder {
public:
  Holder(T *p) : val(p) {}
  long long Get() const { return static_cast<long long>(*val); }
  T *val;
};

using TEST = std::variant<Holder<int>, Holder<char>, Holder<long long>>;

int main() {
  int a = 1;
  char b = 'c';
  long long c = 10000;

  TEST test[3] = {&a, &b, &c};
  for (int i = 0; i < 3; i++) {
    std::visit([](auto &v) { std::cout << v.Get() << std::endl; }, test[i]);
  }
  return EXIT_SUCCESS;
}

Comments

[do_a]

御回答ありがとうございます。
こちらはvariantとテンプレートを使った方法ですね。
variantを知らなかったので驚きです。まだまだ知見が狭いです。参考にさせて頂きます。