使用 std::shared_ptr<void> 指向任何东西

Question

我在我的应用程序中使用std::shared_ptr<void> 来创建一个智能指针，它可以指向许多不同类型的数据结构，如结构、向量、矩阵......基本上任何东西。我正在尝试做的是将一些名称映射到它们的数据结构。

我正在使用哈希表执行映射：

std::unordered_map<std::string, std::shared_ptr<void>>

我可以将find()返回的std::shared_ptr<void>转换回std::shared_ptr<my_type>吗？如果有，怎么做？

更重要的是，这是一种好的做法吗？随着应用程序的扩展，这是否会增加太多的复杂性？或者，还有其他完全不同的优雅方法吗？

编辑

可能无法使用 `Boost.Any'，因为它使用 RTTI。

也不能为所有这些数据结构使用基类，因为其中一些是像std::vector 这样的 STL 容器。

关于下面的答案中讨论的shared_ptr 删除问题，我读到 shared_ptr 执行 类型擦除 并存储类型信息以知道要调用哪个析构函数。

Shared void pointers. Why does this work?

Why do std::shared_ptr<void> work

Why is shared_ptr<void> not specialized?

但我不确定。

Answer 1

这不是一个好习惯。如果你没有在你的std::shared_ptr 旁边存储额外的类型信息（你可以使用static_pointer_cast 进行转换），那么你就会有未定义的行为。也许Boost.Any 适合您？

如果您想坚持使用std::shared_ptr<void>，请记住提供自定义删除器功能（请参阅make shared_ptr not use delete）。

Answer 2

如果你存储void*，那么在每个使用点你都需要知道你输入的确切类型，因为cast-to-void*-and-back 仅在你去/来自确切的相同的类型（例如，不是从无到基派生的）。

鉴于每个使用点都需要知道存储指针的类型，为什么要往返于 void 呢？

您存储的每种类型都有一张地图。与每个应用程序一个映射相比，这具有适度的开销（运行时 O（类型数）内存，类似的编译时间）。

使用 C++ templates 几乎没有代码重复。

Answer 3

我可以将 find() 返回的 std::shared_ptr 转换回 std::shared_ptr 吗？如果有，怎么做？

是的。使用pointer casts。也就是说，在这种情况下，您需要将 void* 转换为具体类型这一事实很可能是设计不佳的症状。

您应该（几乎）永远不需要从 void* 转换为强类型指针类型（“几乎”意味着我认为您永远不应该这样做，但可能有些情况我没有考虑过）。

更重要的是，这是一种好的做法吗？

没有。根据经验，只有当您对内存地址的值感兴趣且对存储的数据完全不感兴趣时​​，才应转换为 void*。

随着应用程序的扩展，这是否会过度增加复杂性？

我能想到的第一个问题是您的类型不再定义在一个地方。这意味着，如果你到处都有指针转换，当你决定你的类名改变了，（或者你不再使用 std::string 作为路径而是使用 boost::path 对象等等），您将不得不遍历代码并更新您添加的所有类型转换中的所有类型。

第二个问题是，随着应用程序的扩展，它会携带这个转换问题并将其传播到代码库中，并使整个代码库的情况变得更糟。由于这个原因，您的应用程序代码将变得稍微（或不那么轻微）难以维护。如果您在整个代码中存在其他设计妥协，超过一定大小，您的应用程序将变得难以维护/令人望而却步。

这种方法只会让您无法编写松散耦合的代码。

或者，还有其他完全不同的优雅方法吗？

检查您的代码并列出您在指针上使用的操作。然后，将这些操作作为纯虚函数添加到基类中。根据存储值类型，实现此基类的具体模板特化。

代码：

class pointer_holder { // get a better name
public:
    virtual void teleport_pointer() = 0; // example operation
    virtual ~pointer_holder() = 0;
};

template<typename T>
class type_holder: public pointer_holder {
public:
    // TODO: add constructor and such
    virtual void teleport_pointer() {
        // implement teleport_pointer for T
    }
    virtual ~type_holder();
private:
    T value_;
};

客户端代码：

std::unordered_map<std::string, std::shared_ptr<pointer_holder>> your_map;
your_map["int"] = new type_holder<int>{10};
your_map["string"] = new type_holder<std::string>{"10"};

your_map["int"]->teleport_pointer(); // means something different for each
                                     // pointer type

Answer 4

你可以。

#include <memory>
#include <iostream>
#include <string>

using namespace std;

class wild_ptr {
    shared_ptr<void> v;
public:
    template <typename T>
    void set(T v) {
        this->v = make_shared<T>(v);
    }

    template <typename T>
    T & ref() {
        return (*(T*)v.get());
    }
};

int main(int argc, char* argv[])
{
    shared_ptr<void> a;
    a = make_shared<int>(3);
    cout << (*(int*)a.get()) << '\n';
    cout << *static_pointer_cast<int>(a) << '\n'; // same as above

    wild_ptr b;
    cout << sizeof(b) << '\n';
    b.set(3);
    cout << b.ref<int>() << '\n';
    b.ref<int>() = 4;
    cout << b.ref<int>() << '\n';

    b.set("foo");
    cout << b.ref<char *>() << '\n';

    b.set(string("bar"));
    cout << b.ref<string>() << '\n';
    return 0;
}

输出：

3
3
8
3
4
foo
bar