有什么方法可以创建包含对不同类型变量的引用的数组/向量？

Question

我很长一段时间以来一直在努力尝试创建一个可以包含对多种类型变量的引用的数组/向量，请参见示例：

class Validate
{
private:
   some_array/vector[]; //0 would refer to x, 1 to y, and so on..
   uint8_t x;
   uint16_t y;
   int32_t z;
public:
   Validate();
   void doSomething(uint8_t &member);
   void doSomething(uint16_t &member);
   void doSomething(int32_t &member);
}

重点是我可以在“for循环”中轻松使用这个数组/向量，如下所示：

void Validate::doSomething(uint_8 &member)
{
   //Do whatever with the variable refered to.
}
Validate::Validate()
{
   for(int i = 0 ; i < 2 ; i++)
      doSomething(some_array/vector[i]);
}

也许有人对我有一个答案或更好的解决方案。

Answer 1

你有两个问题。首先，一个容器不能包含不同类型的元素。其次，您不能将引用存储在容器中。

解决第一个问题的一种方法是使用 C++17 中的std::variant（或boost::variant）。要解决第二个问题，您可以使用std::reference_wrapper:

class Validate {
   using Uint8Ref   = std::reference_wrapper<uint8_t>;
   using Uint16Ref  = std::reference_wrapper<uint16_t>;
   using Uint32Ref  = std::reference_wrapper<int32_t>;
   using MemberType = std::variant<Uint8Ref, Uint16Ref, Uint32Ref>;

   std::vector<MemberType> members;
   uint8_t                 x;
   uint16_t                y;
   int32_t                 z;

public:
   Validate();
   void doSomething(uint8_t &member);
   void doSomething(uint16_t &member);
   void doSomething(int32_t &member);
};

Validate::Validate() : members({std::ref(x), std::ref(y), std::ref(z)}) {    
   for (auto member : members) {
      std::visit([this](auto member){this->doSomething(member);}, member);
   }
}

Live demo.

或者，您可以为可以存储在容器中的成员创建多态基类：

class MemberType {
public:
 virtual ~MemberType(){}
 virtual void accept(Validate& validate) = 0;
};

class Validate {    
   std::array<std::unique_ptr<MemberType>, 3> members;
   // as before...
};

template<typename T>
class MemberTypeImpl : public MemberType {
  T& member;
public:  
  MemberTypeImpl(T& member) : member(member){}
  void accept(Validate& validate) override {
    validate.doSomething(member);
  }
};

template<typename T>
std::unique_ptr<MemberType> make_member_type(T& member) {
  return std::make_unique<MemberTypeImpl<T>>(member);
}

Validate::Validate() 
  : members({make_member_type(x), make_member_type(y), make_member_type(z)}) {
   for (auto& member : members) {
      member->accept(*this);
   }
}