为什么我收到以下代码的以下错误?
1>C:\Libs\boost_1_44\boost/smart_ptr/shared_ptr.hpp(259): error C2683: 'dynamic_cast' : 'my_namespace::A' is not a polymorphic type
1> D:\[location]\[header_filename].h(35) : see declaration of 'my_namespace::A'
1> C:\Libs\boost_1_4
在阅读了之后,我确信这是行不通的。
当我执行此操作时,c_as_b和&c的打印地址是不同的,那么为什么这个打印“看起来比较同一层次结构中的指针是安全的”呢?除了打印的地址外,还有什么比较结果是正确的?
你能给出一个类似的小例子,说明==会导致错误吗?
#include <iostream>
using namespace std;
struct A { std::string s; };
struct B { int i; };
struct C : A, B { double d; };
int main() {
C c;
B* c_as_b = &a
我截取了以下代码:
#include <iostream>
#include <typeinfo>
using namespace std;
class B{
int i;
public:
B(){i = 1;}
virtual int get_i(){return i;}
};
class D: virtual public B{
int j;
public:
D(){j = 2;}
int get_i(){return B::get_i() + j;}
};
class D2: virtual public B{
我有一个程序,其中有指向基类的指针向量,其中存储多个不同派生类的实例。所有这些对象都以不同的方式交互,这取决于它们的类型,我想以一种聪明的方式实现这些交互。我更希望有一个中介类,在那里尽可能多地保存与这些交互相关的代码。
下面是我想要实现的一个简化版本:
#include <iostream>
#include <vector>
class Gesture {};
class Rock : public Gesture {};
class Paper : public Gesture {};
class Scissors : public Gesture {};
在Delphi语言中,我编写了以下代码来识别一个图形是一个TBitmap:
if aImage.Picture.Graphic is TBitmap then
...
在C ++生成器中,我编写了以下代码:
if (dynamic_cast<Image1->Picture->Graphic>(TBitmap) != 0)
....
但它不起作用。如何用在++中做同样的检查?
如果我理解正确的话,typeid可以决定多态性中的实际类型,而typeof不能。
它们的返回是否也用于不同的目的: typeof的返回用作可以定义变量的type关键字,而typeid的返回则不能?
有没有办法既获得多态性的实际类型,又使用return as type关键字来定义另一个变量?我希望从指向基类的指针获取派生类类型,并定义派生类的变量或指针。类似于:
baseclass *p = new derivedclass
typexxx(*p) *pp = dynamic_cast<typexxx(*p) *> (p);
// would like to convert t
我被告知基类指针可以指向该基类的任何派生类型。但是,我需要访问这个派生类,即使参数是调用指向基类的指针。
在这里,Meeting是派生类型,ListItem是基类型,CompareByInsertKey是Meeting::CompareByInsertKey覆盖的ListItem中的一个强制纯虚拟函数,Meeting有一个名为thisdate的结构,其中包含一个成员year。在这个实例中,item_in_list将是一个会议类型,但显然指针仍然工作,即使它是派生类型。
int Meeting::CompareByInsertKey(ListItem* item_in_list)
{
i
每当我尝试运行此代码时,此代码都会返回一个错误。谁能帮帮我。
struct m
{
virtual int s( )
{
return 1;
}
};
struct n : public m
{
int s( )
{
return 2;
}
};
int o( )
{
n* p=new m;
m* q=dynamic_cast<p>;
return q->s( );
}
请参阅以下代码:
void simple_dynamic_casts( )
{
AB ab;
B* bp = (B*)&ab; // cast needed to break protection
A* ap = &ab; // public derivation, no cast needed
AB& abr = dynamic_cast<AB&>(*bp); // succeeds
ap = dynamic_cast<A*>(bp); assert( ap != NUL
什么时候从父到子的dynamic_cast在实践中是有用的?这总是一种糟糕的做法吗?
这不是: 的副本
首先,让我们从一个代码示例开始,然后得出一些结论。
#include<iostream>
using namespace std;
class B { public: virtual void fun() {cout<<"!class B!\n";} };
class D: public B { public: void fun() {cout<<"!class D!\n";} };
int main()
{
我有一个继承自Ai和B的类C。A和B是不相关的。下面的代码很好地解释了这一点。在main()中,我有一个变量a,定义为std::unique_ptr<A>,但用C初始化。我不能改变这个定义。 我的问题是,给定这样定义的a,我如何正确地调用在B、C或Ai中定义的函数? #include <memory>
class A
{
public:
void fun_a() {}
};
class B
{
public:
void fun_b() {}
};
class Ai : public A
{
public:
void fun_
#include <iostream>
using namespace std;
class X{
public:
virtual void f(){}
};
class Y {
public:
virtual void g() {}
};
int main()
{
X * x = new X();
Y* y = dynamic_cast<Y*>(x); //A
// Y* y = static_cast<Y*>(x); //B
cout &l
我正在尝试使用Clang分析一些c++代码。对于下面的代码,我能够将Expr* x作为f-> bar(x)的参数从AST中检索出来。现在,我想要找到x的声明,以便获得它的初始值,但我不确定如何才能做到这一点。我还查看了中的Expr文档,但我找不到任何有用的东西。
struct foo {
int bar(int x) { return x; }
};
int main(){
foo *f;
int x = 0, y = 0;
int y = f->bar(x);
return 0;
}
根据我所读到的,执行错误的运行时dynamic_cast可能抛出bad_cast异常或返回零。
如果你使用指针,那么它将返回零,这是正确的吗?
即:
class Base { virtual void a(){} };
class Derived: public Base {};
int main () {
Base *base = new Base();
dynamic_cast<Derived*>(base);
return 0;
}
以及它在转换对象时会抛出bad_cast异常?
即:
class Base { virtual void a(){} };
cl
#include <iostream>
using namespace std;
class Base
{
public:
void who()
{
cout << "I am " << _name << endl;
}
protected:
std::string _name;
};
class A : public Base
{
public:
A()
{
_name = "A class";
}
};
class B : public Base
{
pub
我有以下的类和方法:
//Base class
class Node {
public:
virtual ~Node() {};
Node() {};
private:
// Private things for my implementation.
};
class Element : public Node {
public:
// Returns the name of the element.
const xml::String &name() const {
我想把这个转换成:
class Base
{
public:
virtual ~Base(){};
};
class Der : public Base {};
int main()
{
const Base* base = new Der;
Der* der = dynamic_cast<Der*>(base); // Error
return 0;
}
我该怎么办?我试着放:const Der* der = dynamic_cast<Der*>(base);来管理const,但这不起作用。
让我说我有两个班,动物和狗像这样。
class Animal
{
};
class Dog : public Animal
{
};
我有一个动物物体叫做动物,它实际上是狗的一个例子,我怎么把它扔回狗呢?这似乎是一个奇怪的问题,但我需要它,因为我正在编写一个编程语言解释器,在堆栈上,一切都存储为BaseObject,所有其他数据类型都扩展了BaseObject。如何将基本对象从堆栈转换为特定的数据类型?我试过这样的方法
Dog dog = static_cast<Dog>(animal);
但它给了我一个错误
1>------ Build started: Projec