因此,如果您从Void*转换为Type*或从Type*转换为Void*,您应该使用:

void func(void *p)
{
    Params *params = static_cast<Params*>(p);
}

要么

void func(void *p)
{
    Params *params = reinterpret_cast<Params*>(p);
}

对我来说static_cast似乎更正确,但我看到两者都用于同一目的.此外,转换的方向是否重要.即我还应该使用static_cast:

_beginthread(func,0,static_cast<void*>(params)

我已经阅读了关于C++样式转换的其他问题但是我仍然不确定这个场景的正确方法是什么(我认为它是static_cast)

在reinterpret_cast我们知道可以将任何指针类型到另一个任何指针类型.关于这个演员运算符我想问的问题是:

1. 如何reinterpret_cast工作,允许reinterpret_cast工作的魔力(内部实现)是什么？
2. 使用时如何确保安全reinterpret_cast？据我所知,它不保证安全铸造,所以在使用时要采取什么预防措施reinterpret_cast?
3. 这个运算符的实际用法是什么？我没有在我的专业编程经验中遇到过这种情况,其中我无法使用此运算符.除了通常的int*to char*之外的任何实际示例将非常有帮助和赞赏.

另外一个关于普通铸造运营问题:
铸造运营商(static_cast,dynamic_cast,const_cast,reinterpret_cast),都称为Operators即是最好的我的理解,因此,它是正确的说法,以使该casting operators cannot be overloaded unlike most other operators(我知道不是所有的运算符可以重载,我知道其中不可能(除了问我,请不要惹恼我)我怀疑这是因为他们是运营商,标准对这些有什么看法？

以下三个强制转换用于提取用于指针算术的原始字节指针有什么区别吗？(假设一个char为1个字节的平台.)

1. static_cast<char*>((void*)ptr))
2. reinterpret_cast<char*>(ptr)
3. (更新)或: static_cast<char*>(static_cast<void*>(ptr))

我应该选择哪个？

更详细......

给定一个类中两个成员对象的指针,我想计算从一个到另一个的偏移量,这样我就可以重建给定偏移量的一个成员的地址和另一个成员的地址.

// assumed data layout:
struct C {
  // ...
  A a;
  // ...
  B b;
}

我目前使用的代码是:

void approach1( A *pa, B *pb )
{
  // compute offset:
  std::ptrdiff_t offset = static_cast<char*>((void*)pa) - static_cast<char*>((void*)pb);
  // then in some other function...
  // given offset and ptr to b, compute ptr to a:
  A *a = static_cast<A*>( (void*)(static_cast<char*>((void*)pb) + offset) );
}

main()
{
  C c;
  approach1(&c.a, &c.b);
}

我想知道以下是否更好(或更糟):

void approach2( A *pa, …

有没有办法在C++中手动递增和递减shared_ptr的计数？

我试图解决的问题如下.我正在用C++编写一个库,但接口必须是纯C.在内部,我想使用shared_ptr来简化内存管理,同时保留通过C接口传递原始指针的能力.

当我通过接口传递一个原始指针时,我想增加引用计数.然后,客户端将负责调用一个函数,该函数将在不再需要传递的对象时减少引用计数.

编辑: 主要目的是允许操作底层数据作为封装结构的一部分,而不是直接数据操作.

在结构中包含一些数据时,建议使用以下哪种方法:

1. 保持指向结构中数据的指针:

   new s(buf),将buf存储在本地字段中(s->buf = buf)

2. 将内存地址重新解释为一个结构:

   reinterpret_cast<s*>(buf)

3. 将new运算符用于数据所在的内存地址:

   new(buf) s;

以下是这些方法的示例程序:

#include <iostream>
using namespace std;

struct s {
    int* i;
    s(int* buf) : i(buf) {}
    int getValue() { return *i * 2; }
};

struct s2 {
    int i;
    int getValue() { return i * 2; }
};

int main() {
    int buf = 10;
    s a(&buf);
    cout << "value: " << a.getValue() << ", size: " << sizeof(a) << ", …

旧式代码:

const string *ps;  
void *pv;

pv = (void*)ps;

我尝试了三种不同的命名演员:

pv = static_cast<void*>(ps); //  error: invalid static_cast from type ‘const string* {aka const std::basic_string<char>*}’ to type ‘void*’

pv = const_cast<void*>(ps); // error: invalid const_cast from type ‘const string* {aka const std::basic_string<char>*}’ to type ‘void*’

pv = reinterpret_cast<void*>(ps); // error: reinterpret_cast from type ‘const string* {aka const std::basic_string<char>*}’ to type ‘void*’ casts away qualifiers

如你看到的.什么都行不通.

有什么区别

int i = 123;
int k;
k = *(int *) &i;
cout << k << endl; //Output: 123

和

int i = 123;
int k;
k = i;
cout << k << endl; //Output: 123

它们都提供相同的输出但是有什么区别吗？

(我在Fast Inverse Square Root的Quake3代码中找到了第一个片段)

我正在看这个答案,我想知道是否使用reinterpret_cast将对象转换为第一个成员并使用结果在C++中是安全的.

假设我们有一个A类,一个B类和一个B的实例b:

class A{
public:
    int i;
    void foo(){}
};

class B{
public:
    A a;
};

B b;

问题1:使用这样的ba是否安全:reinterpret_cast<A*>(&b)->foo()？

注意:在一般情况下,我们假设类及其成员都是标准布局.

我关于reinterpret_cast的可用引用的讲座告诉我这样的用法应该被授权,因为没有别名违规,但是它与许多答案冲突,比如这个.

问题2:使用这样的ba是否安全:static_cast<A*>(static_cast<void*>(&b))->foo()？

在 C++ 中将 void* 转换为 char* 的最佳/最安全方法是什么？

static_cast 还是 reinterpret_cast？

void I2C::Read(void* buffer, DWORD address, UINT size) 
{
    if (_isDeviceAvailable)
    {
        _iicInstance.seekg(address, std::ios_base::beg);
        _iicInstance.read(reinterpret_cast<char *>(buffer), size);
        Gpio::SVSet();
    }

}

我最近 了解到，通过 ing 其地址将 POD 重新解释为不同的 POD 是未定义行为reinterpret_cast。reinterpret_cast所以我只是想知道，如果它不能用于其名称所暗示的用途，那么它的潜在用例可能是什么？