Question

这是交易：

我有一个模板化的C类

template<class T>
class C;

其成员基本上是指向重新解释T的指针，称为P（不要担心P）

P* reint;

我想要做的是一个接收T并将其复制到reint

的方法

void foo (T& param) {
    new (reint) (param);
}

问题是编译器发出的警告是reint不是我想要摆脱的T.我的第一个想法是将reint重新解释为T：

void foo (T& param) {
    new (reinterpret_cast<T&>(*reint)) T(param);
}

但是编译器开始给我一个错误说

invalid conversion from const void* to void*

所以我查了一下，新的定义如下：

void* operator new (std::size_t size, void* ptr) throw();

因此，出于某种原因，我的演员正在将reint变成一个const void *。

新想法：将reint强制转换为T并调用复制构造函数。问题：不知道如何从未知类调用复制构造函数。

（也许

reinterpret_cast<T>(*reint).T(param);

？）

你能帮我吗？

Answer 1

也许你想要这样的东西：

#include <stdexcept>

struct Data
{
    const std::string value;
    Data(const std::string& value)
    :   value(value)
    {}
    Data(const Data& other) = default;
    Data& operator = (const Data& other) = delete;
};

template <typename T>
class Holder
{
    public:
    Holder() = default;
    Holder(const T& data) {
        assign(data);
    }
    ~Holder() {
        release();
    }

    void assign(const T& data) {
        release();
        new (m_data) T(data);
        m_valid = true;
    }

    void release() {
        if(m_valid) {
            reinterpret_cast<T*>(m_data)->~T();
            m_valid = false;
        }
    }

    const T& get() const {
        if( ! m_valid) throw std::runtime_error("Invalid");
        return *reinterpret_cast<const T*>(m_data);
    }

    private:
    bool m_valid = false;
    char m_data[sizeof(T)];
};


#include <iostream>
int main() {
    Holder<Data> holder;
    holder.assign(Data("Hello"));
    const Data& data = holder.get();
    std::cout << data.value << '\n';
}

Answer 2

你要采用错误的方式，你想要的更像是：

reint = reinterpret_cast<P*>(param);

Answer 3

解决方案是创建一个struct来返回const和nonst

的重新解释的P.

template <class T> struct Temp {
    T* switch (P* r) { return reinterpret_cast<T*>(r); }
}

template <class T> struct Temp <const T> {
    T* switch (P* r) { return reinterpret_cast<T*>(r); }
}

然后使用struct从reint中删除const

new (Temp::switch(reint)) T(param);

从没有新的未知类调用复制构造函数

3 个答案: