我可以创建一个只能动态分配的结构吗？

Question

在 C++ 中，我可以创建一个只能动态分配的结构吗？我想强制执行一种方法来确保程序员不能静态分配此结构，因为这样做会导致悬空指针，因为我需要在其范围之外使用指针的内容。

Answer 1

您可以创建一个 struct 私有构造函数，这样就没有人可以从中创建，然后创建一个 friend 函数来创建动态分配的对象和 returns 指向的指针它，如下。

#include <iostream>
struct A{
    ~A() {
        std::cout << "\nA has been destructed";
    }
private:
    A(/*args*/) {
        std::cout << "\nA has been created";
    }
    friend A* creatA(/*args*/);

};
A* creatA(/*args*/){
    return new A(/*args*/);
}

int main()
{
    A* ptr = creatA();
    delete ptr;

}

使用智能指针和@Peter 建议会更好

#include <iostream>
#include <memory>

struct A{
    A(/*args*/) {
        std::cout << "\nA has been created";
    }
    friend std::default_delete<A>;
private:
    ~A() {
        std::cout << "\nA has been destructed";
    }
};

int main()
{
    std::unique_ptr<A> ptr = std::make_unique<A>(/*Args*/);

}

Answer 2

@asmmo 已经解释过了，但我想用 templates 以更通用的方式提供类似的解决方案。据我所知，没有使类只能动态分配的语言功能。这意味着应该模仿我们想要的行为。因此解决方案是使构造函数仅可用于仅动态分配类的函数。

可能的实施方式：

#include <utility>

template<typename T, typename... Args>
inline T* create( Args&&... args )
{
    return new T { std::forward<Args>( args )... };
}

class foo
{
    private:
        foo() {}
        foo( int ) { }

        template<typename T, typename... Args>
        friend T* create( Args&&... );
};

class bar
{
    private:
        bar() {}
        bar( int ) { }

        template<typename T, typename... Args>
        friend T* create( Args&&... );
};

int main()
{
    auto f1 = create<foo>( 15 );
    auto f2 = create<foo>();
    auto b1 = create<bar>();
    auto b2 = create<bar>( 14 );
}

run online

我可以创建一个只能动态分配的结构吗？

Can I create a struct that can only be dynamically allocated?

c++

oop

struct

pointers

dangling-pointer