blocks|key|1086553|text|基本上，任何时候你想让其他类负责你的类的对象的生命周期，或者你有理由阻止对象的销毁，你都可以将析构函数设为私有。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086554|例如，如果你正在做一些引用计数的事情，你可以让对象(或已经被“加为好友”的管理器)负责计算对其自身的引用数量，并在数量达到零时将其删除。当仍有引用时，私有dtor将防止其他任何人删除它。|1086555|再举一个例子，如果您有一个对象，它有一个管理器(或其本身)，它可能会销毁它，或者可能会拒绝销毁它，这取决于程序中的其他条件，例如打开的数据库连接或正在写入的文件。你可以在类或管理器中有一个"request_delete“方法，它将检查该条件，它将删除或拒绝，并返回一个状态，告诉你它做了什么。这比仅仅调用"delete“要灵活得多。|1086556|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Basically, any time you want some other class to be responsible for the life cycle of your class' objects, or you have reason to prevent the destruction of an object, you can make the destructor private.

For instance, if you're doing some sort of reference counting thing, you can have the object (or manager that has been "friend"ed) responsible for counting the number of references to itself and delete it when the number hits zero. A private dtor would prevent anybody else from deleting it when there were still references to it.

For another instance, what if you have an object that has a manager (or itself) that may destroy it or may decline to destroy it depending on other conditions in the program, such as a database connection being open or a file being written. You could have a "request_delete" method in the class or the manager that will check that condition and it will either delete or decline, and return a status telling you what it did. That's far more flexible that just calling "delete".

blocks|key|1086565|text|当你不想让用户访问析构函数时，也就是说，你只想通过其他方式销毁对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086566|http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspx给出了一个例子，其中对象是引用计数的，并且只有当计数变为零时才应该由对象本身销毁。|offset|length|1086567|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspx^0|0|0|1U|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

When you do not want users to access the destructor, i.e., you want the object to only be destroyed through other means.

<a href="http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspx" rel="noreferrer">http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspx</a> gives an example, where the object is reference counted and should only be destroyed by the object itself when count goes to zero.

blocks|key|3670179|text|类只能自己删除。如果您正在创建一些引用计数对象的尝试，则非常有用。然后，只有release方法可以删除对象，这可能会帮助您避免错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3670180|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The class can only be deleted by itself. Useful if you are creating some try of reference counted object. Then only the release method can delete the object, possibly helping you avoid errors.

blocks|key|4515666|text|这样的对象永远不能在堆栈上创建。总是在堆上。而删除必须通过朋友或成员完成。产品可以使用单个对象层次结构和自定义内存管理器--这样的场景可以使用私有dtor。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4515667|#include+<iostream>
class+a+{
++++~a()+{}
++++friend+void+delete_a(a*+p);
};


void+delete_a(a*+p)++{
++++delete+p;
}

int+main()
{
++++a+*p+=+new+a;
++++delete_a(p);

++++return+0;
}|code-block|syntax|javascript|4515668|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Such an object can never be created on the stack. Always on the heap. And deletion has to be done via a friend or a member. A product may use a single Object hierarchy and a custom memory-manager -- such scenarios may use a private dtor.

<pre><code>#include &lt;iostream&gt;
class a {
 ~a() {}
 friend void delete_a(a* p);
};


void delete_a(a* p) {
 delete p;
}

int main()
{
 a *p = new a;
 delete_a(p);

 return 0;
}
</code></pre>

blocks|key|4515707|text|在Windows中，每个模块可以使用不同的堆，例如Debug堆，这可能是解决该问题的一种方法。如果这个问题没有得到正确的处理，就会发生bad+things。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4515708|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/19f56tw3(VS.71).aspx|1|http://blogs.msdn.com/oldnewthing/archive/2006/09/15/755966.aspx|2|https://stackoverflow.com/questions/443147/c-mix-new-delete-between-libs^0|P|5|0|1V|3|1|1Z|6|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

It might be a way to deal with the problem in Windows where each module can use a different heap, such as the <a href="http://msdn.microsoft.com/en-us/library/19f56tw3(VS.71).aspx" rel="nofollow noreferrer">Debug</a> heap. If that problem isn't handled correctly <a href="http://blogs.msdn.com/oldnewthing/archive/2006/09/15/755966.aspx" rel="nofollow noreferrer">bad</a> <a href="https://stackoverflow.com/questions/443147/c-mix-new-delete-between-libs">things</a> can happen.

blocks|key|3670286|text|我知道你问的是私有析构函数。下面是我如何使用受保护的文件。其想法是，您不想通过指向类的指针来删除main类，这会给main添加额外的功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3670287|在下面的示例中，我不希望通过HandlerHolder指针删除GuiWindow。|3670288|class+Handler
{
public:
++++virtual+void+onClose()+=+0;
protected:
++++virtual+~Handler();
};

class+HandlerHolder
{
public:
++++void+setHandler(+Handler*+);
++++Handler*+getHandler()+const;
protected:
++++~HandlerHolder(){}
private:
++++Handler*+handler_;
};

class+GuiWindow+:+public+HandlerHolder
{
public:
++++void+finish()
++++{
++++++++getHandler()->onClose();
++++}

++++virtual+~GuiWindow(){}
};|code-block|syntax|javascript|3670289|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I know you were asking about private destructor. Here is how I use protected ones. The idea is you don't want to delete main class through the pointer to class that adds extra functionality to the main. 
In the example below I don't want GuiWindow to be deleted through a HandlerHolder pointer. 

<pre><code>class Handler
{
public:
 virtual void onClose() = 0;
protected:
 virtual ~Handler();
};

class HandlerHolder
{
public:
 void setHandler( Handler* );
 Handler* getHandler() const;
protected:
 ~HandlerHolder(){}
private:
 Handler* handler_;
};

class GuiWindow : public HandlerHolder
{
public:
 void finish()
 {
 getHandler()-&gt;onClose();
 }

 virtual ~GuiWindow(){}
};
</code></pre>

blocks|key|1086680|text|COM使用此策略删除实例。COM使析构函数成为私有的，并提供用于删除实例的接口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086681|下面是Release方法的一个示例。|1086682|int+MyRefCountedObject::Release()+
{
+_refCount--;
+if+(+0+==+_refCount+)+
+{
++++delete+this;
++++return+0;
+}
+return+_refCount;
}|code-block|syntax|javascript|1086683|ATL+COM对象就是这种模式的主要示例。|1086684|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

COM uses this strategy for deleting the instance. COM makes the destructor private and provides an interface for deleting the instance.

Here is an example of what a Release method would look like.

<pre><code>int MyRefCountedObject::Release() 
{
 _refCount--;
 if ( 0 == _refCount ) 
 {
 delete this;
 return 0;
 }
 return _refCount;
}
</code></pre>

ATL COM objects are a prime example of this pattern.

blocks|key|4515855|text|迪克斯温特是错误的。这是一个在堆栈上创建的具有私有c-tor和d-tor的对象的示例(我在这里使用静态成员函数，但也可以使用friend函数或friend类来完成)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4515856|#include+<iostream>

class+PrivateCD
{
private:
++++PrivateCD(int+i)+:+_i(i)+{};
++++~PrivateCD(){};
++++int+_i;
public:
++++static+void+TryMe(int+i)
++++{
++++++++PrivateCD+p(i);
++++++++cout+<<+"inside+PrivateCD::TryMe,+p._i+=+"+<<+p._i+<<+endl;
++++};
};

int+main()
{
++++PrivateCD::TryMe(8);
};|code-block|syntax|javascript|4515857|此代码将生成output:+inside+PrivateCD::TryMe，p._i+=8|4515858|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

dirkgently is wrong. Here is an example of object with private c-tor and d-tor created on stack (I'm using static member function here, but it can be done with friend function or friend class as well).

<pre><code>#include &lt;iostream&gt;

class PrivateCD
{
private:
 PrivateCD(int i) : _i(i) {};
 ~PrivateCD(){};
 int _i;
public:
 static void TryMe(int i)
 {
 PrivateCD p(i);
 cout &lt;&lt; "inside PrivateCD::TryMe, p._i = " &lt;&lt; p._i &lt;&lt; endl;
 };
};

int main()
{
 PrivateCD::TryMe(8);
};
</code></pre>

This code will produce output:
inside PrivateCD::TryMe, p._i = 8

blocks|key|4515888|text|除了这里已经提供的答案之外，私有构造函数和析构函数在实现需要在堆上分配创建的对象的factory时非常有用。通常，对象将由静态成员或朋友创建/删除。典型用法示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4515889|class+myclass
{
public:
++++static+myclass*+create(/*+args+*/)++//+Factory
++++{
++++++++return+new+myclass(/*+args+*/);
++++}

++++static+void+destroy(myclass*+ptr)
++++{
++++++++delete+ptr;
++++}
private:
++++myclass(/*+args+*/)+{+...+}+++++++++//+Private+CTOR+and+DTOR
++++~myclass()+{+...+}++++++++++++++++++//+
}

int+main+()
{
++++myclass+m;++++++++++++++++++++++++++//+error:+ctor+and+dtor+are+private
++++myclass*+mp+=+new+myclass+(..);+++++//+error:+private+ctor
++++myclass*+mp+=+myclass::create(..);++//+OK
++++delete+mp;++++++++++++++++++++++++++//+error:+private+dtor
++++myclass::destroy(mp);+++++++++++++++//+OK
}|code-block|syntax|javascript|4515890|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Factory_%2528object-oriented_programming%2529^0|15|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Adding to the answers already present here; private constructors and destructors are quite useful while implementing a <a href="http://en.wikipedia.org/wiki/Factory_%28object-oriented_programming%29" rel="noreferrer">factory</a> where the created objects are required to be allocated on the heap. The objects would, in general, be created/deleted by a static member or friend. Example of a typical usage:

<pre><code>class myclass
{
public:
 static myclass* create(/* args */) // Factory
 {
 return new myclass(/* args */);
 }

 static void destroy(myclass* ptr)
 {
 delete ptr;
 }
private:
 myclass(/* args */) { ... } // Private CTOR and DTOR
 ~myclass() { ... } // 
}

int main ()
{
 myclass m; // error: ctor and dtor are private
 myclass* mp = new myclass (..); // error: private ctor
 myclass* mp = myclass::create(..); // OK
 delete mp; // error: private dtor
 myclass::destroy(mp); // OK
}
</code></pre>

What is the use of having destructor as private?

What is the use of having destructor as private?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

将析构函数作为私有函数有什么用？

问将析构函数作为私有函数有什么用？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将析构函数作为私有函数有什么用？EN