Question

我有一些基础class A和一些继承的类：

class B : public A
class C : public A
class D : public A

我有解析一些配置文件的功能，它在配置调用中使用名称：

void do_smth<B>(...);
void do_smth<C>(...);
void do_smth<D>(...);

我有map<A*> objs;并在这些功能中发生：

void do_smth<T>(...)
{
  T *control = new T();
  ...
  objs[name] = T;
}

所以我有指向A的指针。在其他函数中我得到了name，我需要将值存储在B，C或D类中。问题是我不能将虚函数添加到任何会返回这些值的类，因为来自库的A，B，C，D和B有函数value（），C - text（），D - currentValue（）等我需要函数get_value()，它将根据类返回value(), text(), currentValue()的结果？你有什么建议我解决我的问题？

我看到两种方式：

1）我可以从指向类B，C，D的函数编写函数，并调用函数get_value((B*)objs[name]);，但我认为它不好。

2）我可以在创建B，C，D变量时使用我需要的函数创建boost::bind对象。

哪种方式会更好，或者你能告诉我更好吗？

Answer 1

所以你有

A* a;

并且不知道它是什么类型。试试dynamic_cast：

B* b = dynamic_cast<B*>(a);
if ( b ) 
    return b->value();
//C and D the same way

Answer 2

您可以使用类型特征。为每个类B，C，D创建类型特征，以导出每个类的“标识符”（例如，枚举值）。沿objs数组存储此标识符。稍后你可以切换这个标识符，以找出你应该在objs中转换每个元素的类。

class A{};
class B : public A{};
class C : public A{};
class D : public A{};

enum ClassType {B_type, C_type, D_type, Unknown_type};

template<typename T>
struct Identifier{static const ClassType value = Unknown_type;};

template<>
struct Identifier<B>{static const ClassType value = B_type;};

template<>
struct Identifier<C>{static const ClassType value = C_type;};

template<>
struct Identifier<D>{static const ClassType value = D_type;};


template<typename T>
void do_smth()
{
  T *control = new T();
  ...
  objs[name] = control;
  ids[name] = Identifier<T>::value;
}

void test()
{
    do_smth<X>(); // X is of type B, C, D

    ...

    switch (ids[name])
    {
    case B_type:
        {
            B* b = static_cast<B*>(objs[name]);
            // do something with b
            break;
        }
    case C_type:
        {
            C* c = static_cast<C*>(objs[name]);
            // do something with c
            break;
        }
    case D_type:
        {
            D* d = static_cast<D*>(objs[name]);
            // do something with d
            break;
        }
    default:
        ;//error
    };      
}

Answer 3

将A继承到类X，您可以在其中添加可能需要的任何虚函数。

然后从B，C，D继承X并使用X *表示多态性。

在没有那些虚拟原型的情况下调用一个继承类的方法

3 个答案: