从基类指针获取模板派生类值答案

【问题标题】：Getting template derive class's value from base class pointer从基类指针获取模板派生类值
【发布时间】：2019-01-21 08:17:14
【问题描述】：

我有一个允许用户编辑 glsl 的统一变量值的工具，我需要将所有数据存储在 std::vector 中。

由于所有变量的值都有不同的变量类型（vec2、vec3、vec4、mat2...等），将它们存储在单个容器中是一个挑战。我决定采用这种方法

class BaseData
{
    public:
};

template <typename T>
class Data: public BaseData
{
public:

    Data(TypeEnum enumType, T valueIN): value(valueIN), type(enumType)
    {

    }

    T GetValue()
    {
        return value; 
    }

    TypeEnum GetType()
    {
        return type;
    }

private:
    T value;
    TypeEnum type;
};

class Material
{
    Material(std::vector<Base*> valueVec)
    {
        for(auto i : valueVec)
        { 
            switch(i->GetType())
            {
                case BaseColor:
                    SetBaseColor(i->GetValue());//need something like this
                    break;
                case BaseTexture:
                    SetBaseTexture(i->GetValue());//need something like this
                    break;
                case EmissionColor:
                    SetEmissionFactor(i->GetValue());//need something like this
                    break;
                case EmissionTexture:
                    SetEmissionTexture(i->GetValue());//need something like this
                    break;
                case Material_nProps_NormalTexture:
                    SetNormalMap(i->GetValue());//need something like this
            } 
        }
    }
}

int main()
{
    std::vector<BaseData*> uniformValue;

    uniformValue.push_back(new Data(BaseColor, glm::vec4(1,2,3,4)));
    uniformValue.push_back(new Data(BaseTexture, 0));
    uniformValue.push_back(new Data(EmissionColor, glm::vec3(1,1,1)));    
    uniformValue.push_back(new Data(BaseTexture, 1));

    Material PBR(uniformValue);
}

但问题是，现在我如何从基指针中获取 value 而不将其转换为正确的派生类型指针？

【问题讨论】：

如果您的可能类型数量有限，请检查std::variant（或boost::variant，如果您没有 C++17 编译器）和访问者模式 (std::visit)。
嗨@Holt 不幸的是，只允许 c++98 :(
然后就像霍尔特说的，结帐boost。
我知道提升，但同样不适用于我的场景
也许看看'typeid'操作符。

标签： c++ c++98

【解决方案1】：

如果您不想强制转换，可以使用命令模式，其中每个 GLSL 属性类接收指向 Material 对象的指针并执行适当的操作。每个命令都需要访问 Material 的一些内部结构。下面的代码说明了这一点。（请注意，为了简单起见，所有内容都是公开的）。

struct Material; // forward declaration
struct GlslPropertyBase {
    virtual ~GlslPropertyBase() {}
    virtual void Execute(Material* m) = 0;
};

struct Material {
    void SetBaseColor(Vec3 col) { /* Do something */ }
    void SetBaseTexture(GLuint uid) { /* Do something */ }

    Material(std::vector<GlslPropertyBase*> properties) {
        for (GlslPropertyBase* property : properties)
            property->Execute(this);
    }
};

struct GlSlBaseColor : GlslPropertyBase {
    Vec3 color;
    GlSlBaseColor(float r, float g, float b) : color(r, g, b) {}
    void Execute(Material* m) { m->SetBaseColor(color); }
};

struct GlSlBaseTexture : GlslPropertyBase {
    GLuint uid;
    GlSlBaseTexture(GLuint uid) : uid(uid) {}
    void Execute(Material* m) { m->SetBaseTexture(uid); }
};

int main() {
    std::vector<GlslPropertyBase*> properties;
    properties.push_back(new GlSlBaseColor(1, 2, 3));
    properties.push_back(new GlSlBaseTexture(1));

    Material PBR(properties);

    // delete heap objects...
}

这只是一种处理存储在单个向量中的异构 glsl 属性的简单方法（和实现），无需强制转换，可能是@francesco 在his answer 末尾所建议的。

【讨论】：