[C++] 親クラスの static const 変数を子クラスから情報を与えて初期化したい

Question

コード

template<class Derived>
class Base {
private:
  static const std::vector<const char*> paths;
}

class Derived1 : public Base<Derived1> {
private:
  static constexpr const char *path = "どこかのディレクトリへのパス1";
}
class Derived2 : public Base<Derived2> {
private:
  static constexpr const char *path = "どこかのディレクトリへのパス2";
}

質問

上述のコードにおける Base::paths を Derived::path の中にあるファイル一覧で固定したいなと思っています。
探索は、実行時の一番初め、または、初めての実体化時に一度だけにしたいです。
（実行時の一番初めにできたら最もスマート）
paths の const は外したくないです。
…不可能でしょうか？？

うまくいかない例1

template<class Derived>
class Base {
private:
  static const std::vector<const char*> paths = [](){
    std::vector<const char*> paths;

    // Derived::path がディレクトリ、path がその中のファイルとする。疑似コード。
    for (path : Derived::path) { 
      paths.push_back(path);
    }

    return paths;
  }(); // このラムダはコンパイル時定数を返すわけではないので、エラー
}

class Derived : public Base<Derived> {
private:
  static constexpr const char *path = "どこかのディレクトリへのパス";
}

うまくいかない例2

template<const char* path>
class Base {
private:
  static const std::vector<const char*> paths = [](){
    std::vector<const char*> paths;

    for (filename : Derived::path) { 
      paths.push_back(filename);
    }

    return paths;
  }();
};

// Derived は path を使わないので、これで出来ればこれでも良いが…
class Derived : public Base<"どこかのディレクトリへのパス"> {
};

うまくいくけど、Derived のインスタンスを生成するたびに、ディレクトリを捜索してしまう例

template<class Derived>
class Base {
private:
  const std::vector<const char*> paths = [](){
    std::vector<const char*> paths;

    // Derived::path がディレクトリ、path がその中のファイルとする。疑似コード。
    for (path : Derived::path) { 
      paths.push_back(path);
    }

    return paths;
  }(); // このラムダはコンパイル時定数を返すわけではないので、エラー
}

class Derived : public Base<Derived> {
private:
  static constexpr const char *path = "どこかのディレクトリへのパス1";
}

Answer 1

こんにちは。

「うまくいかない例１」はクラス内初期化しようとしているからではないでしょうか？
constはコンパイル時定数までは要求しないです。constは通常は初期化後に変更できないの意味です。

inline staticならクラウ内で定義・初期化できます。ラムダ式でも初期化できるようですね。びっくりです。

#include <iostream>
#include <vector>

template<class Derived>
class Base {
public:
  inline static const std::vector<const char*> paths = [](){
    std::vector<const char*> paths;

    // Derived::path がディレクトリ、path がその中のファイルとする。疑似コード。
//    for (path : Derived::path) { 
      paths.push_back(Derived::path);
      paths.push_back(Derived::path);
      paths.push_back(Derived::path);
//    }

    return paths;
  }(); // このラムダはコンパイル時定数を返すわけではないので、エラー
};

class Derived : public Base<Derived> {
public:
  static constexpr const char *path = "どこかのディレクトリへのパス";
};

int main()
{
    for (auto const* p : Derived::paths)
        std::cout << p << "\n";
    
}

wandbox

---

【コメントを見て追記】
試しに VC++ 2017で上記ソースをコンパイルしてみたら、おっしゃる通りのエラーがでました。

上記回答の前に実はinlineとラムダ式を使わないバージョンを作っていたのですが、そちらは通りました。

#include <iostream>
#include <vector>

template<class Derived>
class Base {
private:
  static const std::vector<const char*> paths;

  static std::vector<const char*> init()
  {
    std::cout << "init()\n";
    std::vector<const char*> paths;

    // Derived::path がディレクトリ、path がその中のファイルとする。疑似コード。
    paths.push_back(Derived::path);
    paths.push_back(Derived::path);
    paths.push_back(Derived::path);

    return paths;
  }
protected:
  const std::vector<const char*> getPaths() const { return paths; }
};

template<class Derived>
const std::vector<const char*> Base<Derived>::paths=Base<Derived>::init();

class Derived : public Base<Derived> {
  friend class Base<Derived>;
private:
  static constexpr const char *path = "どこかのディレクトリへのパス";
public:
  void print()
  {
      for (auto const* p : getPaths())
      {
          std::cout << p << "\n";
      }
  }
};

int main()
{
    std::cout << "main()\n";
    Derived derived;
    derived.print();
}

wandbox

init()はmain()の前に走っていますが、たまたまかも知れません。
ただ、確かboostは、使っているように見せかけることでmain()より前に走らせていましたので、もしかするとある程度は当てにして良いかもしれません。

Comments

[tails]

// このラムダはコンパイル時定数を返すわけではないので、エラー
この説明はなんか、伝えたいことがうまく伝えられませんでした、すみません。

そのようにしたいのですが、手元の環境（Visual Studio 2019）では、Derived::path が見つけられないようで、エラーになってしまいます…
継承　 : public Base<Derived>　の時点では、Derived は不完全型なので、分からないのかな、と思います。
一応、エラー内容は、'path': 'Derived' のメンバーではありません
です。

[Chironian]

Derived::pathはprivateに入っているようです。私は一旦publicへ変更しました。
この辺りは大丈夫ですか？

[Chironian]

その後、VC++でやってみたら、おっしゃる通りでした。回答に追記します。

[tails]

inline だと、その時点で Derived::path が見えないといけないので、ダメみたいですね…
inline ではなく、外部にラムダ式の呼び出しで定義することで、無事コンパイルが通りました。
ありがとうございました！

Answer 2

シングルトンパターンを適用すると初期化を１回に抑えることができます。

シングルトンのベターな実装方法

[追記] 自分なりに不細工なコードを書いてみました。

#include <iostream>
#include <vector>
#include <map>
#include <string>

static std::vector<std::string> getPaths(size_t typeHash, const std::string typeName, const std::string path) {
    static std::map<std::size_t, std::vector<std::string>> m;
    if (m.count(typeHash) == 0) {
        std::cout << "DEBUG: 呼び出されたよん" << std::endl;
        std::vector<std::string> v;
        v.push_back(std::string() + typeName + "の" + path + "でなんか適当なやつ1");
        v.push_back(std::string() + typeName + "の" + path + "でなんか適当なやつ2");
        v.push_back(std::string() + typeName + "の" + path + "でなんか適当なやつ3");
        m.insert(std::make_pair(typeHash, v));
    }
    return m[typeHash];
}

class Base {
protected:
    std::vector<std::string> paths;

public:
    Base(size_t typeHash, std::string typeName, std::string path) {
        paths = getPaths(typeHash, typeName, path);
    };

    void printPaths() {
        for (auto p: paths)
             std::cout << p << std::endl;
    };
};

class A : public Base {
    public: A() : Base(typeid(this).hash_code(), typeid(this).name(), std::string("Path1")) { };
};
class B : public Base {
    public: B() : Base(typeid(this).hash_code(), typeid(this).name(), std::string("Path2")) { };
};
    

int main() {
    {
         A a;
         a.printPaths();
    }
    {
         B b;
         b.printPaths();
    }
    {
         A a;
         a.printPaths();
    }
    return 0;
}

Comments

[tails]

インスタンスは複数生成できる必要があるので、シングルトンパターンは嫌です…

[tails]

なるほど…
確かに、それなら実現できますね！
static な変数をラムダ式として持たせて、paths を初期化しても同じようにできそうです！
ありがとうございます。
（コンストラクタに static な変数を持たせることしか思いつけませんでした…）