向任何指针添加字节偏移的便携且安全的方法

Question

我是 C++ 的新手，还没有掌握该语言的所有复杂性和微妙之处。

在 C++11 中向任何类型的指针添加任意字节偏移量的最可移植、正确和安全的方法是什么？

SomeType* ptr;
int offset = 12345 /* bytes */;
ptr = ptr + offset;             // <--

---

我在 Stack Overflow 和 Google 上找到了很多答案，但它们都提出了不同的建议。我遇到的一些变种：

1. Cast to char *:

   ptr = (SomeType*)(((char*)ptr) + offset);
   

2. 投射到unsigned int：

   ptr = (SomeType*)((unsigned int)ptr) + offset);
   

3. Cast to size_t:

   ptr = (SomeType*)((size_t)ptr) + offset);
   

4. “size_t 和 ptrdiff_t 的大小总是与指针的大小一致。因此，正是这些类型应该用作大型数组的索引，用于存储指针和指针运算。” - CodeProject 上的About size_t and ptrdiff_t

   ptr = (SomeType*)((size_t)ptr + (ptrdiff_t)offset);
   

5. 或者像以前一样，但使用intptr_t instead of size_t，它是有符号的而不是无符号的：

   ptr = (SomeType*)((intptr_t)ptr + (ptrdiff_t)offset);
   

6. 只转换为intptr_t，因为offset 已经是一个有符号整数并且intptr_t is not size_t：

   ptr = (SomeType*)((intptr_t)ptr) + offset);
   

在所有这些情况下，使用旧的 C 风格转换是否安全，或者为此使用 static_cast 或 reinterpret_cast 是否更安全或更便携？

我应该假设指针值本身是无符号的还是有符号的？

Answer 1

我会使用类似的东西：

unsigned char* bytePtr = reinterpret_cast<unsigned char*>(ptr);
bytePtr += offset;

Answer 2

使用reinterpret_cast（或C-style cast）意味着绕过类型系统并且不可移植且不安全。是否正确，取决于您的架构。 如果您（必须）这样做，则暗示您知道自己在做什么，从那时起您基本上就靠自己了。警告就这么多。

如果将数字n 添加到指针或类型T，则将该指针移动n 类型T 的元素。您正在寻找的是一种类型，其中 1 个元素表示 1 个字节。

来自sizeof 5.3.3.1 节：

sizeof 运算符产生对象中的字节数 其操作数的表示。 [...]sizeof(char)、sizeof(signed char) 和 sizeof(unsigned char) 是 1。大小的结果 适用于任何其他基本类型（3.9.1）的是 实现定义。

注意，没有关于sizeof(int)等的声明。

字节的定义（1.7.1.）：

C++ 内存模型中的基本存储单元是字节。一种 字节至少足够大以包含基本的任何成员 执行字符集（2.3）和八位代码单元 Unicode UTF-8 编码形式，由一个连续的序列组成 位数，其数量由实现定义。 [...] 这 C++程序可用的内存由一个或多个序列组成 连续字节。 每个字节都有一个唯一的地址。

因此，如果sizeof 返回字节数且sizeof(char) 为1，则char 的大小为C++ 的一个字节。因此，char逻辑上是 C++ 的一个字节，但不一定是事实上的标准 8 位字节。 将n 添加到char* 将返回一个距离n 字节（就C++ 内存模型而言）的指针。因此，如果您想玩按字节操作对象指针的危险游戏，您应该将其转换为char 变体之一。 如果你的类型也有像const这样的限定符，你也应该把它们转移到你的“字节类型”中。

    template <typename Dst, typename Src>
    struct adopt_const {
        using type = typename std::conditional< std::is_const<Src>::value,
            typename std::add_const<Dst>::type, Dst>::type;
    };

    template <typename Dst, typename Src>
    struct adopt_volatile {
        using type = typename std::conditional< std::is_volatile<Src>::value,
            typename std::add_volatile<Dst>::type, Dst>::type;
    };

    template <typename Dst, typename Src>
    struct adopt_cv {
        using type = typename adopt_const<
            typename adopt_volatile<Dst, Src>::type, Src>::type;
    };

    template <typename T>
    T*  add_offset(T* p, std::ptrdiff_t delta) noexcept {
        using byte_type = typename adopt_cv<unsigned char, T>::type;
        return reinterpret_cast<T*>(reinterpret_cast<byte_type*>(p) + delta);
    }

Example

Answer 3

请注意，NULL 是特殊的。在其上添加偏移量是危险的。
reinterpret_cast 无法删除 const 或 volatile 限定符。更便携的方式是 C 风格的演员表。
reinterpret_cast 具有像 @user2218982 的答案这样的特征，似乎更安全。

template <typename T>
inline void addOffset( std::ptrdiff_t offset, T *&ptr ) { 
    if ( !ptr )
        return;
    ptr = (T*)( (unsigned char*)ptr + offset );
} 

Answer 4

我的没有那么优雅，但我希望更具可读性。 字符 helper_ptr; helper_ptr= (char) ptr;

然后就可以使用 helper_ptr 逐字节遍历了。

ptr = (SomeType*)(((char*)ptr) + 1) 将 ptr 前进 sizeof(SomeType) 而不是 1 个字节。

Answer 5

如果你有：

myType *ptr;

你做到了：

ptr+=3;

编译器肯定会通过以下方式增加您的变量：

3*sizeof(myType)

据我所知，这是执行此操作的标准方法。

如果你想迭代，比如说一个 myType 类型的元素数组，那就是这样做的方法。

好的，如果你想使用

进行投射

myNewType *newPtr=reinterpret_cast < myNewType * > ( ptr )

或者坚持使用普通的旧 C 并执行：

myNewType *newPtr=(myNewType *) ptr;

然后递增