dynamic-cast

问题 I found that dynamic_cast didn't work in a situation where I expected it to, and looking at the typeid of the objects at runtime has made the situation even less clear. I just want a cast from base to derived, and I can't figure out why it's not working. I have a class structure something like this: class BoundaryCondition { public: virtual void DoSomething() = 0; virtual ~BoundaryCondition() { /* * */ } } class ReflectingBc : BoundaryCondition { public: virtual void DoSomething(); } class

问题 If you had the following: class Animal{}; class Bird : public Animal{}; class Dog : public Animal{}; class Penguin : public Bird{}; class Poodle : public Dog{}; Does dynamic_cast just check if one class is a derived class of another, or if one class is a base class of another? So if I had: Bird* bird; Animal* animal; bird = dynamic_cast<Animal*>(bird); animal = dynamic_cast<Bird*>(animal); bird would now point to an Animal class, so that I can use bird->some_function(); and it will call the

问题 If you had the following: class Animal{}; class Bird : public Animal{}; class Dog : public Animal{}; class Penguin : public Bird{}; class Poodle : public Dog{}; Does dynamic_cast just check if one class is a derived class of another, or if one class is a base class of another? So if I had: Bird* bird; Animal* animal; bird = dynamic_cast<Animal*>(bird); animal = dynamic_cast<Bird*>(animal); bird would now point to an Animal class, so that I can use bird->some_function(); and it will call the

问题 If you had the following: class Animal{}; class Bird : public Animal{}; class Dog : public Animal{}; class Penguin : public Bird{}; class Poodle : public Dog{}; Does dynamic_cast just check if one class is a derived class of another, or if one class is a base class of another? So if I had: Bird* bird; Animal* animal; bird = dynamic_cast<Animal*>(bird); animal = dynamic_cast<Bird*>(animal); bird would now point to an Animal class, so that I can use bird->some_function(); and it will call the

问题 If you had the following: class Animal{}; class Bird : public Animal{}; class Dog : public Animal{}; class Penguin : public Bird{}; class Poodle : public Dog{}; Does dynamic_cast just check if one class is a derived class of another, or if one class is a base class of another? So if I had: Bird* bird; Animal* animal; bird = dynamic_cast<Animal*>(bird); animal = dynamic_cast<Bird*>(animal); bird would now point to an Animal class, so that I can use bird->some_function(); and it will call the

来源： https://stackoverflow.com/questions/63993875/dynamic-cast-a-rvalue-reference-unique-ptr

问题 Consider the following program #include <iostream> #include <iomanip> struct A { }; struct C { }; int main() { C *pc = nullptr; A *pa1 = dynamic_cast<A *>( pc ); std::cout << "pa1 == nullptr is " << std::boolalpha << ( pa1 == nullptr ) << '\n'; A *pa2 = pc; std::cout << "pa2 == nullptr is " << std::boolalpha << ( pa2 == nullptr ) << '\n'; } For the both pointer declarations, pa1 and pa2, the compiler reports an error that such an initialization is not allowed. For example the clang HEAD 10.0

问题 I know that following code gives compilation error : class A{ public : virtual void name(){cout<<typeid(this).name()<<endl;}; }; class B:protected A{public : virtual void name(){cout<<typeid(this).name()<<endl;};}; void foo(B* b) { A * a = dynamic_cast<A*>(b); //Error : 'A' is an inaccessible base of 'B' return; } But then why in the C++ Stroustrup book (15.4.1) he writes class BB_ival_slider:public Ival_slider,protected BBslider{ //... }; void f(BB_ival_slider*p) { // ok BBslider* pbb2 =

问题 Scott Meyer in his book Effective C++ says dynamic_cast is used to perform safe casts down or across an inheritance hierarchy. That is, you use dynamic_cast to cast pointers or references to base class objects into pointers or references to derived or sibling base class objects in such a way that you can determine whether the casts succeeded. Failed casts are indicated by a null pointer (when casting pointers) or an exception (when casting references). I would like to get two code snippet

问题 I needed run-time polymorphism, so I used dynamic_cast . But now I had two problems -- dynamic_cast was extremely slow ! (Scroll down for benchmark.) Long story short, I ended up solving the problem this way, using static_cast : struct Base { virtual ~Base() { } virtual int type_id() const = 0; template<class T> T *as() { return this->type_id() == T::ID ? static_cast<T *>(this) : 0; } template<class T> T const *as() const { return this->type_id() == T::ID ? static_cast<T const *>(this) : 0; }