是否可以"browse"结构的成员来简化 BDD 类的生成？

下面的代码只是一个例子，说明如何制作自己的"变量类型感知"结构，这可能是您想要的：

#include <vector>
enum MyTypes
{
LONG,
CHARPTR,
DOUBLE,
} myTypes;
struct MyStruct
{
MyStruct(long longVar)
{
variable.longVar = longVar;
whichType = LONG;
}
MyStruct(char* charPtr)
{
variable.charPtr = charPtr;
whichType = CHARPTR;
}
MyStruct(double var)
{
variable.var = var;
whichType = DOUBLE;
}
~MyStruct()
{
}
MyTypes whichType;
union {
long longVar;
char* charPtr;
double var;
} variable;
};
void DoSomethingForLong(MyStruct* doubleStruct)
{
/*Do something specific to long*/
};
void DoSomethingForCharPtr(MyStruct* doubleStruct)
{
/*Do something specific to char pointer*/
};
void DoSomethingForDouble(MyStruct* doubleStruct)
{
/*Do something specific to double*/
};
int main()
{
std::vector<MyStruct*> myVec;
// add a struct with long variable
long longVar = 2000000000;
MyStruct* myLongStruct = new MyStruct(longVar);
myVec.push_back(myLongStruct);
// add a struct with char pointer
char* charArray = new char[1000];
MyStruct* myCharPtrStruct = new MyStruct(charArray);
myVec.push_back(myCharPtrStruct);
// add a struct with double variable
double doubleVar = 200.200;
MyStruct* myDoubleStruct = new MyStruct(doubleVar);
myVec.push_back(myDoubleStruct);
for (int i = 0; i < myVec.size(); ++i)
{
MyStruct* tempStruct = myVec[i];
if (tempStruct->whichType == LONG)
{
DoSomethingForLong(tempStruct);
}
else if (tempStruct->whichType == CHARPTR)
{
DoSomethingForCharPtr(tempStruct);
}
else if (tempStruct->whichType == DOUBLE)
{
DoSomethingForDouble(tempStruct);
}
}
if (myLongStruct)
{
delete myLongStruct;
myLongStruct = nullptr;
}
if (myCharPtrStruct)
{
if (charArray)
{
delete[] charArray;
charArray = nullptr;
}
delete myCharPtrStruct;
myCharPtrStruct = nullptr;
}
if (myDoubleStruct)
{
delete myDoubleStruct;
myDoubleStruct  = nullptr;
}
}

如果您需要添加一个成员函数来将数据成员导出为元组，那么我们可以使用一些模板元编程来实现这一点。

实时演示(C++14)

第一，修改：

struct MYSTRUCT0
{
char variable0[10];
char variable1[70];
std::tuple<char(&)[10], char(&)[70]> GetData()
{
return std::tie(variable0, variable1);
}
};
struct MYSTRUCT1
{
long variable0;
long variable1;
char variable2[6];
double variable3;
std::tuple<long&, long&, char(&)[6], double&> GetData()
{
return std::tie(variable0, variable1, variable2, variable3);
}
};

std::tie将把对这些成员的引用放入tuple中。

元组的好处在于它将所有类型编码到一个列表中，我们可以利用这个列表。(您可能会编写宏来为您创建这些结构。)

从这里开始，策略是编写一个可以处理任何元组的函数。

由于我们通过调用std::get<i>来访问元组的元素，其中i是某个索引，所以我们需要一种方法来获取这些元素的索引，因此我们引入了一种间接级别来使用std::index_sequence:来创建它们

template<class... T>
void ProcessData(const std::tuple<T...>& data){
std::cout << "Processing " << sizeof...(T) << " data elements...n";
detail::ProcessDataImpl(data, std::make_index_sequence<sizeof...(T)>{});
}

detail::ProcessDataImpl的定义将使用一种称为简单包扩展的技术。这是一个技巧，我们利用数组初始化为参数包中的每个元素调用一个函数。这看起来有点奇怪，但请耐心等待：

template<class... T, size_t... I>
void ProcessDataImpl(const std::tuple<T...>& data, std::index_sequence<I...>){
using swallow = int[];
(void)swallow{0, (void(ProcessElement(std::get<I>(data))), 0)...};
}

这将为元组中的每个元素调用一个名为ProcessElement的函数。我们使用逗号运算符和void强制转换来确保函数不会真正执行任何操作，并且我们所有的操作都只是针对它们的副作用(调用我们的ProcessElement函数)。

我们的ProcessElement函数将使用另一个间接级别来传递参数，以便处理更复杂的类型，如字符数组。否则，我们可以为我们需要的类型过载：

template<class T>
struct ProcessElementImpl
{
static void apply(const T& element)
{
static_assert(sizeof(T) == 0, "No specialization created for T");
}
};
template<size_t N>
struct ProcessElementImpl<char[N]>
{
static void apply(const char(&arr)[N])
{
std::cout << "Process char array of size " << N << std::endl;
}
};
template<class T>
void ProcessElement(const T& element)
{
ProcessElementImpl<T>::apply(element);
}
void ProcessElement(long _element)
{
std::cout << "Process a longn";
}
void ProcessElement(double _element)
{
std::cout << "Process a doublen";
}

注意，我们重载了long和double，但我们将其传递给了字符数组的ProcessElementImpl。这是必需的，因为我们不能部分专门化模板函数，并且我们希望处理任意大小的数组。

基类模板还包含一个static_assert，因此我们必须编写一个用于导出数据类型的专门化。

最后我们可以这样称呼它：

int main()
{
MYSTRUCT0 struct0;
ProcessData(struct0.GetData());
MYSTRUCT1 struct1;
ProcessData(struct1.GetData());
return 0;
}

输出：

Processing 2 data elements...
Process char array of size 10
Process char array of size 70
Processing 4 data elements...
Process a long
Process a long
Process char array of size 6
Process a double