blocks|key|1672201|text|这就是所谓的RTTI，但是您几乎肯定想在这里重新考虑您的设计，因为找到类型并基于它做特殊的事情会使您的代码更加脆弱。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1672202|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Run-time_type_information^0|6|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

This is called <a href="https://en.wikipedia.org/wiki/Run-time_type_information" rel="noreferrer">RTTI</a>, but you almost surely want to reconsider your design here, because finding the type and doing special things based on it makes your code more brittle.

blocks|key|1672222|text|您正在寻找dynamic_cast<B*>(pointer)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1672223|entityMap^0|5|P|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

You are looking for <code>dynamic_cast&lt;B*&gt;(pointer)</code>

blocks|key|1672299|text|你的描述有点令人困惑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1672300|一般来说，尽管一些C%2B%2B实现有相应的机制，但您不应该询问类型。相反，您应该在指向A的指针上执行dynamic_cast。这将在运行时检查指向A的指针的实际内容。如果你有一个B，你会把指针指向B，否则，你会得到一个异常或null。|1672301|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Your description is a little confusing. 

Generally speaking, though some C++ implementations have mechanisms for it, you're not supposed to ask about the type. Instead, you are supposed to do a dynamic_cast on the pointer to A. What this will do is that at runtime, the actual contents of the pointer to A will be checked. If you have a B, you'll get your pointer to B. Otherwise, you'll get an exception or null.

blocks|key|1457297|text|可能会在对象中嵌入一个ID“标签”，并使用它来区分A类对象和B类对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1457298|然而，这显示了设计中的一个缺陷。理想情况下，B中A没有的那些方法应该是A的一部分，但保留为空，并且B会覆盖它们。这就去掉了特定于类的代码，更符合OOP的精神。|1457299|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Probably embed into your objects an ID "tag" and use it to distinguish between objects of class A and objects of class B.

This however shows a flaw in the design. Ideally those methods in B which A doesn't have, should be part of A but left empty, and B overwrites them. This does away with the class-specific code and is more in the spirit of OOP.

blocks|key|1457403|text|正如其他人指出的那样，您可以使用dynamic_cast。但是，通常使用dynamic_cast来找出您正在处理的派生类的类型，这表明设计很糟糕。如果你正在重写一个以A的指针作为参数的函数，那么它应该能够使用类A本身的方法/数据，而不应该依赖于类B的数据。在你的例子中，如果你确定你正在编写的方法只适用于类B，那么你应该在类B中编写一个新的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1457404|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

As others indicated you can use dynamic_cast. But generally using dynamic_cast for finding out the type of the derived class you are working upon indicates the bad design. If you are overriding a function that takes pointer of A as the parameter then it should be able to work with the methods/data of class A itself and should not depend on the the data of class B. In your case instead of overriding if you are sure that the method you are writing will work with only class B, then you should write a new method in class B.

blocks|key|1457429|text|使用重载函数。不需要dynamic_cast甚至RTTI支持：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1457430|class+A+{};
class+B+:+public+A+{};

class+Foo+{
public:
++++void+Bar(A&+a)+{
++++++++//+do+something
++++}
++++void+Bar(B&+b)+{
++++++++Bar(static_cast<A&>(b));
++++++++//+do+B+specific+stuff
++++}
};|code-block|syntax|javascript|1457431|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use overloaded functions. Does not require dynamic_cast or even RTTI support:

<pre><code>class A {};
class B : public A {};

class Foo {
public:
 void Bar(A&amp; a) {
 // do something
 }
 void Bar(B&amp; b) {
 Bar(static_cast&lt;A&amp;&gt;(b));
 // do B specific stuff
 }
};
</code></pre>

blocks|key|1457470|text|动态类型转换最适合您对问题的描述，但我只想补充一句，您可以通过以下命令找到类类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1457471|#include+<typeinfo>

...
string+s+=+typeid(YourClass).name()|code-block|syntax|javascript|1457472|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Dynamic cast is the best for your description of problem, 
but I just want to add that you can find the class type with:

<pre><code>#include &lt;typeinfo&gt;

...
string s = typeid(YourClass).name()
</code></pre>

blocks|key|1457509|text|因为您的类不是多态的。尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1457510|struct+BaseClas+{+int+base;+virtual+~BaseClas(){}+};
class+Derived1+:+public+BaseClas+{+int+derived1;+};|code-block|syntax|javascript|1457511|现在BaseClas是多态的。我将class改为struct，因为在默认情况下，struct的成员是公共的。|offset|length|style|CODE|1457512|entityMap^0|0|0|2|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Because your class is not polymorphic. Try:

<pre><code>struct BaseClas { int base; virtual ~BaseClas(){} };
class Derived1 : public BaseClas { int derived1; };
</code></pre>

Now <code>BaseClas</code> is polymorphic. I changed class to struct because the members of a struct are public by default.

blocks|key|1672649|text|为了完成，我将在Robocide的基础上构建build，并指出typeid可以单独使用，而不使用name()：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1672650|#include+<typeinfo>
#include+<iostream>

using+namespace+std;

class+A+{
public:
++++virtual+~A()+=+default;+//+We're+not+polymorphic+unless+we
++++++++++++++++++++++++++++//+have+a+virtual+function.
};
class+B+:+public+A+{+}+;
class+C+:+public+A+{+}+;

int
main(int+argc,+char*+argv[])
{
++++B+b;
++++A&+a+=+b;

++++cout+<<+"a+is+B:+"+<<+boolalpha+<<+(typeid(a)+==+typeid(B))+<<+endl;
++++cout+<<+"a+is+C:+"+<<+boolalpha+<<+(typeid(a)+==+typeid(C))+<<+endl;
++++cout+<<+"b+is+B:+"+<<+boolalpha+<<+(typeid(b)+==+typeid(B))+<<+endl;
++++cout+<<+"b+is+A:+"+<<+boolalpha+<<+(typeid(b)+==+typeid(A))+<<+endl;
++++cout+<<+"b+is+C:+"+<<+boolalpha+<<+(typeid(b)+==+typeid(C))+<<+endl;
}|code-block|syntax|javascript|1672651|输出：|1672652|a+is+B:+true
a+is+C:+false
b+is+B:+true
b+is+A:+false
b+is+C:+false|1672653|entityMap^0|V|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Just to be complete, I'll build build off of Robocide and point out that <code>typeid</code> can be used alone without using name():

<pre><code>#include &lt;typeinfo&gt;
#include &lt;iostream&gt;

using namespace std;

class A {
public:
 virtual ~A() = default; // We're not polymorphic unless we
 // have a virtual function.
};
class B : public A { } ;
class C : public A { } ;

int
main(int argc, char* argv[])
{
 B b;
 A&amp; a = b;

 cout &lt;&lt; "a is B: " &lt;&lt; boolalpha &lt;&lt; (typeid(a) == typeid(B)) &lt;&lt; endl;
 cout &lt;&lt; "a is C: " &lt;&lt; boolalpha &lt;&lt; (typeid(a) == typeid(C)) &lt;&lt; endl;
 cout &lt;&lt; "b is B: " &lt;&lt; boolalpha &lt;&lt; (typeid(b) == typeid(B)) &lt;&lt; endl;
 cout &lt;&lt; "b is A: " &lt;&lt; boolalpha &lt;&lt; (typeid(b) == typeid(A)) &lt;&lt; endl;
 cout &lt;&lt; "b is C: " &lt;&lt; boolalpha &lt;&lt; (typeid(b) == typeid(C)) &lt;&lt; endl;
}
</code></pre>

Output:

<pre><code>a is B: true
a is C: false
b is B: true
b is A: false
b is C: false
</code></pre>

I have a class A and another class that inherits from it, B. I am overriding a function that accepts an object of type A as a parameter, so I have to accept an A. However, I later call functions that only B has, so I want to return false and not proceed if the object passed is not of type B.

What is the best way to find out which type the object passed to my function is?

Finding the type of an object in C++

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个类A和另一个继承自它的类B。我重写了一个函数，这个函数接受类型A的对象作为参数，所以我必须接受一个A。然而，我后来调用了只有B有的函数，所以我想返回false，如果传递的对象不是类型B，就不继续。找出传递给函数的对象是哪种类型的最好方法是什么？

问在C++中查找对象的类型
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中查找对象的类型EN