C++；虚拟方法的类型转换替代方案 在C++中，可以使用虚拟方法来实现如下代码： #包括 #包括 类基类{ 公众： 虚拟std:：string class_name（）常量{返回“基类”；} }; 类第一类：公共基类{ int值=1； 公众： std:：string class_name（）常量{return“FirstClass”；} }; 第二类：公共基类{ 长值=-1； 公众： std:：string class_name（）常量{return“SecondClass”；} }; int main（）{ 常量int数组_size=5； 第一模式下的常数布尔=真； 作废*数据； int样本大小； 如果（在第一种模式下）{ 数据=新的第一类[数组大小]； 样本大小=sizeof（一级）； }否则{ 数据=新的第二类[数组大小]； 样本大小=sizeof（二级）； } //这是与类无关的代码 for（int index=0；index

感谢@ForEveR，我找到了解决方案。我需要使用模板

这意味着，如果在上述示例中，第一类和第二类没有基类，则可以这样做：

#include <iostream>
#include <string>

class FirstClass {
    int value = 1;
public:
    std::string class_name() const { return "FirstClass"; }
};

class SecondClass {
    long long value = -1;
public:
    std::string class_name() const { return "SecondClass"; }
};

template <typename T>
void do_my_stuff(void* void_pointer) {
    T *pointer = static_cast<T*>(void_pointer);
    std::cout << pointer->class_name() << std::endl;
}

int main() {
    const int array_size = 5;
    const bool in_first_mode = true;

    void *data;
    int sample_size;
    if (in_first_mode) {
        data = new FirstClass[array_size];
        sample_size = sizeof(FirstClass);
    } else {
        data = new SecondClass[array_size];
        sample_size = sizeof(SecondClass);
    }

    for (int index = 0; index < array_size; ++index) {
        if (in_first_mode) {
            do_my_stuff<FirstClass>(data + index * sample_size);
        } else {
            do_my_stuff<SecondClass>(data + index * sample_size);
        }
    }

    return 0;
}

#包括
#包括
头等舱{
int值=1；
公众：
std:：string class_name（）常量{return“FirstClass”；}
};
二等舱{
长值=-1；
公众：
std:：string class_name（）常量{return“SecondClass”；}
};
模板
void do_我的东西（void*void_指针）{
T*pointer=静态强制转换（无效指针）；
std:：cout class_name（）如果类不相关，则可以将它们存储在
std:：variant
中（如果编译器不符合C++17，则使用Boost.variant），并通过访问者访问值。这比模板更灵活，因为它允许在变量类型中包含具有不同接口的类型

例如（我没有编译这段代码）：

#包括
#包括
#包括
#包括
结构类型{
std:：string class_name（）常量{return“Type one”；}
};
结构类型二{
int值=1；
std:：string class_name（）常量{return“Type two”；}
};
结构类型三{
长值=-1；
//注意不同的函数签名
静态std:：string class_name（）{return“Type three”；}
};
结构类型四{
std:：string getMyClassName（）常量{return“Type four”；}
};
结构访问者{
模板
void运算符（）（T&&value）常量{
std：：它们有不同的方法吗？如果没有-你可以使用模板。如果是-你应该像处理不同的类一样使用它们。将函数指针存储在数组中，并使用
type
作为索引。@永远，我如何使用模板来实现这一点？@Dmitry我不知道你的实际代码-所以我不能回答你。@knivil，我的重点不是重复c除了
指针
类型之外，ode是绝对相似的。如果我理解正确，你建议为每种类型编写不同但相似的函数，这并不能消除重复。但我认为OP想要
std:：variant
这正是我想要的-一个优雅的解决方案。当这些功能将登陆编译器（GCC 7，Clang 4.0，MSVC 2017-所有这些都将很快发布）。现在我将使用模板解决方案，因为我不想只为此使用boost。
#include <iostream>
#include <string>
#include <variant>
#include <vector>

struct TypeOne {
    std::string class_name() const { return "Type one"; }
};

struct TypeTwo {
    int value = 1;
    std::string class_name() const { return "Type two"; }
};

struct TypeThree {
    long long value = -1;
    // note the different function signature
    static std::string class_name() { return "Type three"; }
};

struct TypeFour {
    std::string getMyClassName() const { return "Type four"; }
};

struct Visitor {
    template <class T>
    void operator ()(T&& value) const {
        std::cout << value.class_name() << std::endl;
    }

    // special case        
    void operator ()(const TypeFour& value) const {
        std::cout << value.getMyClassName() << std::endl;
    }
};

int main() {
    typedef std::variant<TypeOne, TypeTwo, TypeThree, TypeFour> Variant;
    std::vector<Variant> values;
    values.emplace_back(TypeOne{});
    values.emplace_back(TypeTwo{});
    values.emplace_back(TypeThree{});
    values.emplace_back(TypeFour{});

    for (const auto& var : values) {
        std::visit(Visitor{}, var);
    }
}