C++ 使用可以是两种类型之一的数据成员初始化

最好用一些代码来解释：

class MyClass {
  public:
    MyClass(const std::string& d1, const std::string& d2, const std::vector<AorB>& d3) : data1(d1), data2(d2), data3(d3) {}

    std::string getData1();
    std::string getData2();
    std::vector<AorB> getData3();

  private:
    std::string data1;
    std::string data2;
    std::vector<AorB> data3;
}

int main() {
  MyClass myClassA("d1", "d2", std::vector<A>());
  MyClass myClassB("d1", "d2", std::vector<B>());

  A myA = myClassA.getData3();
  B myB = myClassB.getData3();
}

class-MyClass{
公众：
MyClass（const std:：string&d1，const std:：string&d2，const std:：vector&d3）：data1（d1），data2（d2），data3（d3）{}
std:：string getData1（）；
std:：string getData2（）；
std:：vector getData3（）；
私人：
std：：字符串数据1；
std：：字符串数据2；
std：：矢量数据3；
}
int main（）{
MyClass myClassA（“d1”、“d2”、std:：vector（））；
MyClass myClassB（“d1”、“d2”、std:：vector（））；
A myA=myClassA.getData3（）；
B myB=myClassB.getData3（）；
}

使用boost变体或boost any时，此工作流“几乎”起作用，但我试图避免的是调用boost:：get对getData3的结果进行处理以获取实际类型。换句话说，我不想让MyClass的使用者知道是A还是B存储在data3中。我只是希望他们能够调用getData3（），它是创建时传递的任何类型

我认为通过具有模板专门化/递归继承的模板是可能的，但我不太清楚如何使其工作。也许看起来会像这样

class MyClass {
  public:
    template <typename AorB>
    MyClass(const std::string& d1, const std::string& d2, const std::vector<AorB>& d3) : data1(d1), data2(d2), data3(d3) {}

    std::string getData1();
    std::string getData2();

    template <typename AorB>
    std::vector<AorB> getData3();

  private:
    std::string data1;
    std::string data2;

    template <typename AorB>
    std::vector<AorB> data3;
  }

  int main() {
    MyClass myClassA<A>("d1", "d2", std::vector<A>());
    MyClass myClassB<B>("d1", "d2", std::vector<B>());

    A myA = myClassA.getData3();
    B myB = myClassB.getData3();
  }

class-MyClass{
公众：
样板
MyClass（const std:：string&d1，const std:：string&d2，const std:：vector&d3）：data1（d1），data2（d2），data3（d3）{}
std:：string getData1（）；
std:：string getData2（）；
样板
std:：vector getData3（）；
私人：
std：：字符串数据1；
std：：字符串数据2；
样板
std：：矢量数据3；
}
int main（）{
MyClass myClassA（“d1”、“d2”、std:：vector（））；
MyClass myClassB（“d1”、“d2”、std:：vector（））；
A myA=myClassA.getData3（）；
B myB=myClassB.getData3（）；
}

---

但是，这不起作用，因为我们不能有非静态模板类成员。

要执行您正在尝试的操作，您需要将模板作为一个整体应用于

MyClass

，例如：

模板
类MyClass{
公众：
MyClass（const std:：string&d1，const std:：string&d2，const std:：vector&d3）：data1（d1），data2（d2），data3（d3）{}
std:：string getData1（）；
std:：string getData2（）；
std:：vector getData3（）；
私人：
std：：字符串数据1；
std：：字符串数据2；
std：：矢量数据3；
};
int main（）{
MyClass myClassA（“d1”、“d2”、std:：vector（））；
MyClass myClassB（“d1”、“d2”、std:：vector（））；
A myA=myClassA.getData3（）；
B myB=myClassB.getData3（）；
}

要执行您正在尝试的操作，您需要将模板作为一个整体应用于

MyClass

，例如：

模板
类MyClass{
公众：
MyClass（const std:：string&d1，const std:：string&d2，const std:：vector&d3）：data1（d1），data2（d2），data3（d3）{}
std:：string getData1（）；
std:：string getData2（）；
std:：vector getData3（）；
私人：
std：：字符串数据1；
std：：字符串数据2；
std：：矢量数据3；
};
int main（）{
MyClass myClassA（“d1”、“d2”、std:：vector（））；
MyClass myClassB（“d1”、“d2”、std:：vector（））；
A myA=myClassA.getData3（）；
B myB=myClassB.getData3（）；
}

您可以在此处使用union来设置创建时所需的数据类型以及检索时所获得的数据类型。 联合为其所有成员分配一个公共内存位置。工会占用的内存将足够大，足以容纳工会中最大的成员

union AorB
   {
         A;
         B;
   };

---

然后在上述程序中使用

您可以在此处使用union来设置创建时所需的数据类型以及检索时所获得的数据类型。 联合为其所有成员分配一个公共内存位置。工会占用的内存将足够大，足以容纳工会中最大的成员

union AorB
   {
         A;
         B;
   };

---

然后在上面的程序中使用

您是否尝试复制

std:：vector

或

std:：variant

？是否从公共基继承

A

和

B

？如果不是，我真的不明白“我不想让MyClass的使用者知道A或B是否存储在data3中”，因为一旦他们调用

getData3

，用户就知道你试图复制的是什么类型的

std:：vector

或

std:：variant

？

A

和

B

继承自一个公共基吗？如果不是，我真的不明白“我不想让MyClass的使用者知道A或B是否存储在data3中”因为一旦他们调用

getData3

用户就知道它使用的是什么类型的

union

将不允许从

getData3

返回

a

或

B

，除非您建议返回union，这会让调用者知道哪一个是活动成员，使用

联合

而不是使用

变量

没有任何好处使用

联合

将不允许从

getData3

返回

a

或

B

，除非您建议返回联合，这会让调用者知道哪一个是活动成员，使用

联合

而不是使用

变体

没有任何好处，这只是一个微不足道的修复，现在感觉有点愚蠢。是的，这正是我想要的，谢谢！哦，那只是个小问题，现在感觉有点傻了。是的，这正是我想要的，谢谢！