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

在下面的代码中，我想使用

dynamic\u cast

转换从

std:：vector

计算

B类对象的出现次数。但是结果是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;
}

//示例程序
#包括
#包括
#包括
使用名称空间std；
阶级基础{
公众：
Base（）{}；
虚~Base（）{}；
};
A类：公共虚拟基地{
公众：
A（）{}；
虚拟~A（）{}；
};
B类：公共虚拟基地{
公众：
B（）{}；
虚拟~B（）{}；
};
D类：公共A、公共B{
公众：
D（）{}；
虚拟~D（）{}；
};
int main（）
{
int c=0；
std：：向量v；
std:：vector:：迭代器myIt；
v、 向后推（新底座（））；
v、 向后推（新的A（））；
v、 向后推（新B（））；
v、 向后推（新的D（））；
for（myIt=v.begin（）；myIt！=v.end（）；myIt++）
如果（B*object=dynamic_cast（*myIt））
C++；
cout您已经依赖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++;

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

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

我相信有一种叫做
RTTI
运行时类型信息的东西。PS：我来自Java背景向量中有2个
B
s（任何
D
都是a
B
）所以你得到的结果是正确的为什么你需要这个？它闻起来像一个XY问题。如果
D
s不应该是
B
s，那么
D
不应该公开继承
B
处理这个问题的优雅方法是在
Base
中定义某种
std:：string typeName.
字段。然后每个cl从
Base
继承的ass可能会将此字段设置为适当的名称。
c = std::count_if(begin(v), end(v), 
      [&](Base *item) { return b_ti == typeid(*item); }
    );