Question

在下面的代码中，我想使用class B转换从std::vector计算dynamic_cast对象的出现次数。但结果为2 ，应该 1 。发生这种情况是因为dynamic_cast因为继承而将class D的对象检查为class B的对象。

有没有办法检查多重继承的派生类类型而没有这个问题？在这种情况下，C ++中是否存在等效的Java实例？

// Example program
#include <iostream>
#include <string>
#include <vector>


using namespace std;

class Base{

public:  
Base(){};
virtual ~Base(){};
};

class A:public virtual Base{
public:
A() {};
virtual ~A(){};

};

class B:public virtual Base{
public:
B(){};
virtual ~B(){};


};


class D: public A, public B{
public:

D(){};
virtual ~D(){};

};

int main()
{

 int c=0;
std::vector<Base*> v;
std::vector<Base*>::iterator myIt;

v.push_back(new Base());
v.push_back(new A());
v.push_back(new B());
v.push_back(new D());

for(myIt=v.begin(); myIt!=v.end();myIt++)
    if(B* object=dynamic_cast<B*>(*myIt))
        c++;
cout<<c<<endl;
return 0;
}

Answer 1

您已经依赖于RTTI，因此不会产生更多成本。您可以做的是通过调用typeid替换动态强制转换。它只会检查完全动态类型：

// At the top
#include <typeinfo>
#include <typeindex>

//...

std::type_index const b_ti = typeid(B);

for(myIt=v.begin(); myIt!=v.end();myIt++)
    if(b_ti == typeid(**myIt)) // Need to pass an lvalue of type B, hence the double asterisk
        c++;

旁注，但您应该考虑将循环替换为基于循环的范围。它会使整个事物更具可读性：

for(Base *item : v)
  if(b_ti == typeid(*item))
    ++c;

或者更好的是，一个命名算法：

c = std::count_if(begin(v), end(v), 
      [&](Base *item) { return b_ti == typeid(*item); }
    );

Answer 2

这是一个更长的构建时间（编译时）任务，而不是运行时任务。如果您可以控制源和对象定义，那么您应该认为它是一个协议程序，这意味着您可以添加一个类型成员，甚至可以为您更安全和标准地定义一些为您做这些的MACRO。喜欢：

#define STANDARD_OBJ( CLASSNAME_, REST_ ) \
   class CLASSNAME_ REST_ { \
      const char* typename = #CLASSNAME_ ; \
   public: const char* type() { return typename; } \
   protected:

但是不依赖于上面的代码这是最基本的方法，甚至不使用元编程。将有两种主要方式来实现它：预处理器和/或元编程。

但我认为您需要的更像是design-pattern而不是某些代码段。用一种支持这种模式的模式更好一点;比如Factory-Pattern

C ++ - 是否可以在多重继承中检查派生类类型？

2 个答案: