标签: dynamic-cast

通过这个(RTTI有多贵？),似乎很清楚动态转换比静态类型比较昂贵,但我想知道在编译器选项(VS2010,/ GR-)中关闭RTTI选项是否值得

我的代码中没有动态强制转换(我用静态转换替换它们).但是(/ GR-)选项除了在使用动态强制转换时发出错误之外还有吗？那里有内存或代码优化吗？

提前致谢.

我偶然发现了从派生类到派生类的横向转换，并发现了我的知识差距。直到现在，我一直生活在一个可以做到这一点的世界。相反，std::bad_cast被抛出。这里发生了什么？

#include <iostream>

class Base
{
protected:
    int x_;

public:
    Base(int x) : x_(x) {}
    virtual ~Base() = default;
    int x() const { return x_; }
    virtual void setX(int x) = 0;
};

class Editable : public Base // class implements setters
{
public:
    Editable(int x) : Base(x) {}
    void setX(int x) { x_ = x; }
};

class ReadOnly : public Base // class implements empty setters
{
public:
    ReadOnly(int x) : Base(x) {}
    void setX(int x) …

我正在研究一些遗留代码,它们有这样的几行:

try
{
    object = dynamic_cast< Object* >( _object );
}

凡_object已经是一个Object*开始.代码中有一条关于试图避免崩溃的评论_object.我的问题是,如果有的话,这是如何工作的？是否dynamic_cast仍然这样做的东西,如果开始和结束的类型是一样的吗？

还有另一个地方,他们正在做同样的事情,dynamic_cast但它不是在尝试块.是否有任何指向动态转换为相同的确切类型或可能只是"坏"代码？

我希望标题有意义。我可能缺少正确表达它的词汇。

嗯，举个例子可能会更清楚。

我的问题是：在以下某些情况下（写在注释中），动态向下转换在运行时返回 0。我想知道这是否是正确的行为（使用 C++11），以及为什么，以及我能做些什么来使其工作。显然，Templated 和 A::A_templated 被视为不同的类，尽管通过使用别名“using”定义为相同的类。对于简单的 typedef 别名，不会出现问题。

template <class T>
class Templated {};

class A {
    public :
    typedef int A_Type;
    template <class T>
    using A_Templated = Templated<T>;
};

class Test_base {
    public :
    Test_base() {}
    virtual void foo()=0;
};

template <class T>
class Test_Type : public Test_base {
    public :
    Test_Type() {}
    void foo() {}
};

template < template <class T> class TT >
class Test_Templated : public Test_base {
    public :
    Test_Templated() {}
    void foo() …

这是我的问题的后续内容： Updating data Members of different obliged Class of the same base class inside a vector

我正在 C++ 中构建一个 3D 网格模型，它具有不同的单元类型，所有单元类型都存储在Grid类中的向量中。我定义了一个GridCell基类，并且还有几个派生类GridCell1、GridCell2、GridCell3等。

我将GridCell对象传递到模型进程中。传递的GridCell对象类型（其派生类）将与接收模型进程一起使用。换句话说，模型进程模型进程被设计（可能是不正确的），具有不同的函数，期望对适当的派生对象的数据成员进行操作。当然，他们看不到，因为对象是从 中拉出的，std::vector<gridCell*> gridCellVector所以它只将该对象视为指向基类的指针。此时，我有两个选择：1）重写我的模型流程，2）使用static_cast或dynamic_cast向下转换传递的对象。

问题：在这种情况下，当我的模型进程（仅在正确类型的GridCell对象上运行）知道它们正在接收什么派生类时，我应该使用 static_cast 还是dynamic_cast？人们似乎真的不喜欢使用这些工具。为什么我应该远离使用这些？

什么是C++中的Dynamic_cast中的side-cast/ cross-cast.有人能解释一个例子吗？

#include <iostream>
using namespace std;

class A
{
    virtual void fn(){} 
};
class B:public A
{

};
class C:public A
{

};
int main() {

    B b;
    C* c;

    {
        c = dynamic_cast<C*> (&b);  
    }
    if(!c)
    {
        cout<<"invalid cast "<<endl;
    }
    return 0;
}

它打印无效的演员表.那么,是什么side-cast？

C++是否有现有的方法来检查对象是否是派生类型的对象？例如,

class A
{};

class B : public A
{};

A* p;

并检查是否p指向B.

标准草案 N4618 是这样说的std::pmr::monotonic_buffer_resource：

bool do_is_equal(const memory_resource& other) const noexcept override;

Run Code Online (Sandbox Code Playgroud)

返回： this == dynamic_cast<const monotonic_buffer_resource*>(&other)

换句话说，标准不只是将指针与 进行比较，而是this == &rhs希望供应商不遗余力地使用dynamic_cast右手指针。

我想不出任何理智的情况dynamic_cast会改变比较的结果。不过，我可以想到一些疯狂的案例：

class new_delete_memory_resource : public memory_resource {
    void *do_allocate(size_t bytes, size_t align) override {
        return ::operator new(bytes, align);
    }
    void *do_deallocate(void *p, size_t bytes, size_t align) override {
        ::operator delete(p, bytes, align);
    }
    bool do_is_equal(const memory_resource& rhs) const noexcept override {
        return (this == &rhs);
    }
};
class TwoHeadedResource …

例如，我刚刚看到了一个包含 dynamic_cast from std::exceptionto的代码std::nested_exception，

try {
    std::throw_with_nested(std::runtime_error("error"));
} catch (std::exception &e) {
    auto &nested = dynamic_cast<std::nested_exception&>(e);
    std::cout << "ok" << std::endl;
}

第一次，我认为这段代码不会被编译，因为std::nested_exception它不是派生自std::exception，我希望dynamic_cast会对继承进行静态检查，但我错了。

虽然我找不到明确提到dynamic_cast允许这样做的相关标准规范，但我确认所有三个主要编译器（clang/gcc/msvc）都允许dynamic_cast完全不相关的类型。

但是，仍然std::nested_exception不是从 派生的std::exception，所以我认为dynamic_cast将抛出bad_alloc异常并且"ok"永远不会打印。我又错了。

现在，我想知道这是如何工作的。这对std::exceptionand 来说有什么特别的和特殊的std::nested_exception吗？或者，我可以dynamic_cast<A&>(b)在A对象的类型和类型b没有公共基类的情况下取得另一个成功吗？

在 static_cast、dynamic_cast、reinterpret_cast 和 const_cast 中，只有 static_cast 能够返回所需类型的对象，而其他类型只能返回指针或对表示的引用。为什么会这样呢？

例子：

int y = 3;
double z = reinterpret_cast<double> (y);//error
double z = reinterpret_cast<double&> (y);//ok
double z = static_cast<double> (y);//but this is ok!!!

const int y = 3;
int z = const_cast<int> (y);//error
int z = const_cast<int&> (y);//ok

对于dynamic_cast：

using namespace std;

class Gun
{
public:
    virtual void shoot(){
        cout << "BANG!\n";
    }
};

class MachineGun : public Gun{
public:
    void shoot() override{
        cout <<"3X-BANG\n";
    }
};

int main()
{
    Gun gun;
    MachineGun …