memcpy 或 std::copy 用于我的特定应用程序

Question

我正在尝试为一些遗留 C 代码编写一个 C++ 包装器，以提高它的类型安全性并减少使用 PITA 的次数。遗留代码与共享内存中的指针交互。 POD 结构是从这些指针转换而来的。由于是共享内存，这些结构保证是POD。

C 代码充满了 memcpy 个实例。我想知道在这种情况下使用 std::copy 而不是 memcpy 是否是个好主意，或者最好不要管它。

例如原代码（伪代码表示）：

// we cast from a void pointer return from the shared memory segment
void *ptr = FunctionToReturnPointer();
descriptor_p = (descriptor_t*)new char[sizeof(descriptor_t)];
memcpy(descriptor_p, ptr, sizeof(descriptor_t));

其中 descriptor_t 是 POD 结构。在我的解决方案中，我可能会做这样的事情（以伪代码表示）：

// provide a casting class that can do everything
template <typename T>
class CastClass {
    static T* Cast() {
        void *ptr = FunctionToReturnPointer();
        T *t = new T;
        std::copy(ptr, ptr + sizeof(T), t);
        return t;
    }
};

// And how I would use the function
descriptor_p = CastClass<descriptor_t>::Cast();

所以这是我的问题：

这样做有好处吗？还是这是徒劳的？
我是否在代码中添加了类型安全？
我对 std::copy 算法的使用是否正确？

Answer 1

std::copy(ptr, ptr + sizeof(T), t);

不对。

首先，我认为您不能在对 std::copy

的调用中传递 void* 类型的对象

即使你做了类似的事情：

T* ptr = static_cast<T*>(FunctionToReturnPointer());
...
std::copy(ptr, ptr + sizeof(T), t);

有问题。

假设 T == int 和 sizeof(int) 是 4。

std::copy 的用法将尝试复制：

*t 到 *ptr
*(t+1) 到 *(ptr+1)
*(t+2) 到 *(ptr+2) 和
*(t+3) 到 *(ptr+3)

您的代码没有为这么多对象分配内存，将导致未定义的行为。

Answer 2

两者都不行如何？只需使用正确类型的指针让对象的默认复制分配工作即可：

descriptor_t* descriptor_p = new descriptor_t;
*descriptor_p = *(descriptor_t*)(FunctionToReturnPointer());

一行：

descriptor_t* descriptor_p = new descriptor_t(*(descriptor_t*)(FunctionToReturnPointer()));

模板版本：

template<typename T>
T* MakeNewCopy(void* p) { return new T(*static_cast<T*>(p)); }

auto p = MakeNewCopy<descriptor_t>(FunctionToReturnPointer());

这将比您现在看起来的要干净得多，但如果您为模板提供了错误的类型，编译器将无法帮助您，因此 "safe" 是一个相对术语。任何时候你使用 void* 并施放它，你都在脱掉手套。尝试尽可能多地包含该行为，以便您的代码几乎只处理正确类型的指针。

Answer 3

你真的需要在堆上动态分配副本吗？

// provide a casting class that can do everything
template <typename T>
class CastClass {
    public:
    static T Cast() {
        T *ptr = (T*) FunctionToReturnPointer();
        return *ptr; // return a copy of the data
    }
};

descriptor_t descriptor_p = CastClass<descriptor_t>::Cast();

如果你确实需要一个指针，那么至少使用unique_ptr来管理它：

// provide a casting class that can do everything
template <typename T>
class CastClass {
    public:
    static std::unique_ptr<T> Cast() {
        T *ptr = (T*) FunctionToReturnPointer();
        return new T(*ptr); // return a managed pointer to a copy of the data
    }
};

std::unique_ptr<descriptor_t> descriptor_p = CastClass<descriptor_t>::Cast();

memcpy 或 std::copy 用于我的特定应用程序

memcpy or std::copy for my particular application

c++

algorithm

memcpy