C++不可破坏类

C++ Non-destructible classes

本文关键字：可破坏 C++      更新时间：2023-10-16

C++中有没有任何方法可以在函数中创建类，然后防止它被破坏？像

class someclass {
public:
int x;
someclass() { x = 0; };
}
someclass::x;

然后在某个地方

someclass * somefunction()
{
someclass somecl ();
return &somecl;
}

所以我们调用函数"somefunction"，并获取指向类的指针以供以后使用。只要程序运行/它被其他函数破坏，我就需要它存在。有没有什么方法可以做到这一点，而不将其存储在数组或向量中？

我不确定您正在寻找的是一种只定义一次对象的方法，每次都返回一个指向同一对象的指针，还是创建一个每次都返回新构建对象的工厂函数。如果是第二个，请查看以前的答案。如果是第一个，请检查static变量。例如，您可以编写

someclass * somefunction()
{
    static someclass somecl ();
    return &somecl;
}

这样可以确保somecl在函数最初运行时只定义一次，并且在程序退出之前一直有效。(有关static变量清理顺序的更精确描述，请参阅此处。(

是的，您必须在堆上分配内存，然后在完成后delete分配内存。

someclass * somefunction()
{
    return new someclass();
}
int main()
{
    someclass * myclass = somefunction();
    // do stuff with myclass
    delete myclass;
    return 0;
}

someclass * somefunction()
{
    return new somecl ();
}

你非常接近：(

您可以在堆而不是堆栈上创建它：

someclass * somefunction()
{ 
   return new someclass();
}

您可能还想考虑在智能指针中返回它，以明确地转移所有权并控制其生存期。

我不太确定你在做什么，我可以想象两种不同的用例，你想让一个类坚不可摧。

案例1：辛格尔顿
实现这一点的惯用方法是使用在访问器函数中声明的类的静态实例：

class Foo {
    public:
        static Foo& globalFoo();
    private:
        Foo() {};
        ~Foo() {};
};
Foo& Foo::globalFoo() {
    static Foo myFoo;
    return myFoo;
}
int main() {
    Foo& myFoo = Foo::globalFoo();
}

这样，其他代码就不可能构造或销毁Foo的任何实例，它只能使用globalFoo()函数提供的一个实例。

案例2：包装分配/解除分配
如果你只想通过某些静态函数强制分配/解除分配，你只需要使构造函数和析构函数都是私有的(就像在singleton的情况下一样(，并将静态函数添加到用于分配/解除的接口：

class Foo {
    public:
        static Foo* makeFoo();
        static void destroyFoo(Foo* aFoo);
    private:
        Foo() {};
        ~Foo() {};
};
Foo* Foo::makeFoo() {
    return new Foo();
}
void Foo::destroyFoo(Foo* aFoo) {
    delete aFoo;
}
int main() {
    Foo* myFoo = Foo::makeFoo();
    Foo::destroyFoo(myFoo);
}
相关文章：