Question

对于一个系统，我需要将指针转换为long，然后将long指针转换为指针类型。你可以猜到这是非常不安全的。我想要做的是使用dynamic_cast进行转换，所以如果我混合它们，我会得到一个空指针。此页面显示http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=/com.ibm.vacpp7l.doc/language/ref/clrc05keyword_dynamic_cast.htm

dynamic_cast运算符执行在运行时键入转换。该 dynamic_cast运算符保证将指针转换为基数 class到指向派生类的指针，或转换左值将基类引用到对派生类的引用。一个程序因此可以使用一个类等级安全。这个操作员和 typeid运算符提供运行时类型信息（RTTI）支持 C ++。

如果它为null，我想得到一个错误，所以我写了自己的动态演员

template<class T, class T2> T mydynamic_cast(T2 p)
{
    assert(dynamic_cast<T>(p));
    return reinterpret_cast<T>(p);
}

使用MSVC我收到错误“错误C2681：'long'：dynamic_cast的表达式类型无效”。事实证明，这只适用于具有虚拟功能的类...... WTF！我知道动态转换的意义在于上/下转换继承问题，但我也认为这是动态解决类型转换问题。我知道我可以使用reinterpret_cast，但这并不能保证同样的安全性。

我应该使用什么来检查我的类型转换是否是同一类型？我可以比较两个typeid，但是当我想将一个派生类型转换为它的基数时，我会遇到问题。那我怎么解决这个问题呢？

Answer 1

dynamic_cast只能在通过继承相关的类之间使用。要将指针转换为long（反之亦然），可以使用reinterpret_cast。要检查指针是否为空，您可以assert(ptr != 0)。但是，通常不建议使用reinterpret_cast。为什么需要将指针转换为long？

另一个选择是使用联合：

union  U { 
int* i_ptr_;
long l;
}

同样，联盟也很少需要。

Answer 2

请记住，在Windows 64中，指针将是64位数量，但long仍然是32位数量，并且您的代码已损坏。至少，您需要根据平台选择整数类型。我不知道MSVC是否支持uintptr_t，这是C99中用于保存指针的类型;如果它可用，这将是最好的类型。

至于其他人，其他人已经充分解决了dynamic_cast vs reinterpret_cast的原因和原因。

Answer 3

在用仅支持C接口的语言编写的应用程序中加载C ++ DLL时，我不得不做类似的事情。如果传入了意外的对象类型，这个解决方案将立即给您带来错误。这可以使出现问题时更容易诊断。

诀窍在于，作为句柄传递的每个类都必须从公共基类继承。

#include <stdexcept>
#include <typeinfo>
#include <string>
#include <iostream>
using namespace std;


// Any class that needs to be passed out as a handle must inherit from this class.
// Use virtual inheritance if needed in multiple inheritance situations.
class Base
{

public:
    virtual ~Base() {} // Ensure a v-table exists for RTTI/dynamic_cast to work
};


class ClassA : public Base
{

};

class ClassB : public Base
{

};

class ClassC
{
public:
    virtual ~ClassC() {}
};

// Convert a pointer to a long handle.  Always use this function
// to pass handles to outside code.  It ensures that T does derive
// from Base, and that things work properly in a multiple inheritance
// situation.
template <typename T>
long pointer_to_handle_cast(T ptr)
{
    return reinterpret_cast<long>(static_cast<Base*>(ptr));
}

// Convert a long handle back to a pointer.  This makes sure at
// compile time that T does derive from Base.  Throws an exception
// if handle is NULL, or a pointer to a non-rtti object, or a pointer
// to a class not convertable to T.
template <typename T>
T safe_handle_cast(long handle)
{
    if (handle == NULL)
        throw invalid_argument(string("Error casting null pointer to ") + (typeid(T).name()));

    Base *base = static_cast<T>(NULL); // Check at compile time that T converts to a Base *
    base = reinterpret_cast<Base *>(handle);
    T result = NULL;

    try
    {
        result = dynamic_cast<T>(base);
    }
    catch(__non_rtti_object &)
    {
        throw invalid_argument(string("Error casting non-rtti object to ") + (typeid(T).name()));
    }

    if (!result)
        throw invalid_argument(string("Error casting pointer to ") + typeid(*base).name() + " to " + (typeid(T).name()));

    return result;
}

int main()
{
    ClassA *a = new ClassA();
    ClassB *b = new ClassB();
    ClassC *c = new ClassC();
    long d = 0; 


    long ahandle = pointer_to_handle_cast(a);
    long bhandle = pointer_to_handle_cast(b);
    // long chandle = pointer_to_handle_cast(c); //Won't compile
    long chandle = reinterpret_cast<long>(c);
    // long dhandle = pointer_to_handle_cast(&d); Won't compile
    long dhandle = reinterpret_cast<long>(&d);

    // send handle to library
    //...
    // get handle back
    try
    {
        a = safe_handle_cast<ClassA *>(ahandle);
        //a = safe_handle_cast<ClassA *>(bhandle); // fails at runtime
        //a = safe_handle_cast<ClassA *>(chandle); // fails at runtime
        //a = safe_handle_cast<ClassA *>(dhandle); // fails at runtime
        //a = safe_handle_cast<ClassA *>(NULL); // fails at runtime
        //c = safe_handle_cast<ClassC *>(chandle); // Won't compile
    }
    catch (invalid_argument &ex)
    {
        cout << ex.what() << endl;
    }

    return 0;
}

Answer 4

dynamic_cast<>是一个仅适用于 convertible 类型的转换（在多态意义上）。强制将pointer强制转换为long（litb正确建议static_assert以确保大小的兼容性）所有有关指针类型的信息都将丢失。没有办法实现safe_reinterpret_cast<>来获取指针：值和类型。

澄清我的意思：

struct a_kind {}; 
struct b_kind {}; 

void function(long ptr) 
{} 

int 
main(int argc, char *argv[]) 
{ 
    a_kind * ptr1 = new a_kind; 
    b_kind * ptr2 = new b_kind;

    function( (long)ptr1 );
    function( (long)ptr2 );

    return 0;
}

function()无法确定传递的指针类型，并且“向下”将其强制转换为正确的类型，除非：{/ p>

long被一个包含该类型信息的对象包裹。
类型本身在引用的对象中编码。

这两种解决方案都是丑陋的，应该避免使用，因为它们是RTTI的替代品。

Answer 5

您可以使用reinterpret_cast强制转换为整数类型并返回指针类型。如果整数类型足以存储指针值，那么该转换不会改变指针值。

正如其他人已经说过的那样，在非多态类上使用dynamic_cast并不是定义的行为（除非你做了一个upcast，无论如何都是隐式的，并且在这里被忽略），它也只适用于指针或引用。不是整数类型。

您最好使用各种posix系统中的::intptr_t。您可以将该类型用作您投射到的中间类型。

关于检查转换是否成功，您可以使用sizeof：

BOOST_STATIC_ASSERT(sizeof(T1) >= sizeof(T2));

如果无法完成转换，

将在编译时失败。或者继续在该条件下使用assert，它将在运行时断言。

警告：这不会阻止您将T* intptr_t转发回U*，而使用其他类型的广告来回到T*。因此，这只能保证如果您从intptr_t投射到T*并返回{{1}}，则投射将不会更改指针的值。（感谢Nicola指出你可能会期待另一种保护）。

Answer 6

reinterpret_cast是在这里使用的正确演员。

这几乎是唯一它可以安全地做的事情。

从指针类型到类型T的reinterpret_cast并返回到原始指针类型会产生原始指针。（假设T是指针或整数类型，至少与原始指针类型一样大）

请注意，未指定从指针类型到T的reinterpret_cast。无法保证T类型的值，除之外，如果您将其重新解释为广播类型，则会得到原始值。因此，假设您没有尝试使用中间长值进行任何操作，reinterpret_cast非常安全且便携。

编辑：当然，如果您在第二次演员时不知道原始类型是什么，这无济于事。在那种情况下，你被搞砸了。 long不可能以任何方式携带有关从哪个指针转换的类型信息。

Answer 7

你想要做的事情听起来像是一个非常糟糕和危险的想法，但如果你必须这样做（即你在遗留系统或你知道永远不会改变的硬件上工作），那么我建议包装某种包含两个成员的简单结构中的指针：1）指向对象实例的void指针和一个字符串，枚举或其他类型的唯一标识符，它们将告诉您将原始void *转换为什么。这是我的意思的一个例子（注意：我没有打扰测试这个，因此可能存在语法错误）：

struct PtrWrapper {
  void* m_theRealPointer;
  std::string m_type;
};

void YourDangerousMethod( long argument ) {

   if ( !argument ) 
     return;

   PtrWrapper& pw = *(PtrWrapper*)argument;

   assert( !pw.m_type.empty() );

   if ( pw.m_type == "ClassA" ) {
     ClassA* a = (ClassA*)pw.m_theRealPointer;
     a->DoSomething();
   } else if (...) { ... }

}

Answer 8

另外，最好使用size_t而不是long - 我认为这种类型可以确保与地址空间的大小兼容。

Answer 9

一旦你决定将一个指针指向一个长指针，你就会把类型的安全性抛到风中。

dynamic_cast用于投射＆amp;下一个派生树。也就是说，从基类指针到派生类指针。如果你有：

class Base
{
};

class Foo : public  Base
{
};

class Bar : public Base
{
};

您可以这样使用dynamic_cast ......

Base* obj = new Bar;

Bar* bar = dynamic_cast<Bar*>(obj); // this returns a pointer to the derived type because obj actually is a 'Bar' object
assert( bar != 0 );

Foo* foo = dynamic_cast<Foo*>(obj);  // this returns NULL because obj isn't a Foo
assert( foo == 0 );

...但是你不能使用动态强制转换来推导出派生树。你需要reinterpret_cast或C风格的演员表。

安全地检查变量的类型

9 个答案: