Question

我有这个基本设置：

enum{
    BASE,
    PRIMITIVE,
    ...
};

class IUnknown{
public:
    bool inline is(int type){return inv_type == type;}
private:
    enum {inv_type = BASE};
};

class Primitive: public IUnkown{
private:
    enum {inv_type = PRIMITIVE};
};

我的问题是我希望能够在Primitive实例上调用is并且当type等于我在Primitive类中声明的枚举中的值时返回true。

我找到的唯一解决方案是将'是'函数声明为虚拟并在每个子类中都有一个副本，但我想知道是否有可能以某种方式重新定义枚举并拥有是IUnkown中的函数从那里获取值

Answer 1

enum本身不会占用存储空间，因为它们只是enum变量的可接受值列表。您必须为虚拟函数启用一些运行时存储才能实际使用对象的运行时类型。我只想使用int或其他东西：

enum{
    BASE,
    PRIMITIVE,
    ...
};

class IUnknown{
public:
    bool is(int type) const {return inv_type == type;}

protected:
    IUnknown(int type) : inv_type(type) { }

private:
    const int inv_type;
};

class Primitive: public IUnkown{
private:
    Primitive() : IUnknown(PRIMITIVE) { }
};

Answer 2

你可以让你的IUnknown类定义一个受保护的构造函数（然后必须从每个派生类调用它）。它将采用其中一个枚举值并存储它。然后将存储的值与is（）方法进行比较。

如果你不喜欢这个，并且喜欢向IUnknown添加一个虚拟的is（）方法，但又不想在每个派生类中定义它，你可以这样做：

template <int Tinv_type>
class IUnknownT : public IUnknown{
public:
    virtual bool is(int type){return inv_type == type;}
protected:
    enum {inv_type = Tinv_type};
};

class Primitive: public IUnknownT<PRIMITIVE>{
};

Answer 3

为什么不全力以赴使用字符串而不是枚举。

const char * baseStr = "base";
const char * derived1Str = "derived1";
const char * derived2Str = "derived2";

class base
{
public:
    virtual bool is(const char * str)
    {
        return strcmp(baseStr, str) ? false : true;
    }
};

class derived1 : public base
{
public:
    bool is(const char * str)
    {
        if ( strcmp(derived1Str, str) )
            return base::iA(str);

        return true;
    }
};

class derived2 : public derived1
{
public:
    bool is(const char * str)
    {
        if ( strcmp(derived2Str, str) )
            return derived1::is(str);

        return true;
    }
};

这有利于这个

base * b = new derived2();
bool is = b->isA(baseStr);

将is设置为true。

c ++通过枚举定义对象类型

3 个答案: