关于析构的自动与手动调用
#include "stdio.h"
#include <iostream>

using namespace std;
class A{
public:
~A(){cout << "xigou"<< endl;}
};

main(){
A* a = new A();
a->~A();
a->~A();
a->~A();

getchar();
delete a;

getchar();
}

该程序在vc,gcc下均正常运行
想说明的是
1.手动析构 == 调用函数
2.自动析构 == 调用函数同时销毁本身，后一个行为由系统完成，用户不能参与

若果还是不明白，我无语
[解决办法]
你的说明是错误的。析构函数无论显式还是隐式调用，类对象都被销毁，不再存在了。在此之后对该对象的操作都属于未定义行为。
[解决办法]

引用:

你的说明是错误的。析构函数无论显式还是隐式调用，类对象都被销毁，不再存在了。在此之后对该对象的操作都属于未定义行为。

还是别说了，人家不信标准的。
[解决办法]
............
[解决办法]
膜拜一下。
看过《execptional c++》item40/41的人飘过。
[解决办法]

引用:

#include "stdio.h"
#include <iostream>

using namespace std;
class A{
public:
~A(){cout << "xigou"<< endl;}
};

main(){
A* a = new A();
a->~A();
a->~A();
a->~A();

getchar();
delete a;……

#include<iostream>
#include<algorithm>
using namespace std;


class Test
{
public:
Test(void):_ch(new char)
{
*_ch = '*';
}
~Test(void)
{
delete _ch;
}

void PrintCh(void){ cout<<*_ch; }
private:
char *_ch;
};

int main(int argc, char **argv)
{
Test t;
t.PrintCh();

t.~Test();

t.PrintCh(); //请解释下这里为什么会挂掉...楼主态度温和点，大家都在学习^^

return EXIT_SUCCESS;
}
[解决办法]
析构可以手动、自动的调用，自动调用会销毁本身，手动不会，同是是否支持手动析构时对同一内存的多次释放由编译器决定
-----------------------------------------------------------------------------
没看见里面的举例？？？

[Example: if the destructor for an automatic object is explicitly invoked, and the block is subsequently left in a manner that would ordinarily invoke implicit destruction of the object, the behavior is undefined. ]

你明白什么叫explicitly invoked么？






本人比较讨厌说undefined 了，标准之所以undefined ，是因为大千世界变化莫测的，无法全部defined
但 实现必须是defined，否则就是二义了
只有极少数的undefined 情况会在不同编译器之间产生分歧
undefined 的情况之所以成为undefined ，是因为当时不知道如何defined ，或者哪种defined是合适的
最终都将被实践一一defined掉
若有undefined 情况，请先怀疑自己是否学懂了，同时坚信不久将来必定被defined掉

一家之言，晒晒体会，见笑了
---------------------------------------------------------------------
我笑了，真的.......
[解决办法]
你们天天过招,我好学习.
谢谢啦
[解决办法]
英文字母都视若无物，你牛，我投降.......
[解决办法]

#include<iostream>
#include<cstring>
using namespace std;


    struct Test{
  char *p;
  Test():p(new char[5]){strcpy(p,"hello");}
  void print(){ cout<<p<<endl;}
  ~Test(){ delete []p;p=NULL;}
};

int main()
{
    Test obj;
    obj.print();
    obj.~Test();
    obj.print();
    
    system("Pause");
    return 0;
}    

就在之前的那个帖子里面的代码。自己运行，我知道你很喜欢敲代码的。
[解决办法]

引用:

你们天天过招,我好学习.
谢谢啦

你来晚了，我已经投降了......
[解决办法]
我不明白手动调用析构函数有什么意义呀？
[解决办法]

引用:

引用:
你的说明是错误的。析构函数无论显式还是隐式调用，类对象都被销毁，不再存在了。在此之后对该对象的操作都属于未定义行为。


我不同意，请指出 手动析构后对象被销毁的证据，不是析构函数里面打印的东东
是证明该对象不能被正确访问的证据

我举的例子里面可以说明 手动析构后对象仍能被正常使用

能正常使用也属于未定义的一类
Once a destructor is invoked for an object, the object no longer exists;
直译：一旦调用了某对象的析构函数，该对象不再存在

至于怎么证明这种“仍然可以正常使用”的情况属于未定义的，感觉应该让懂汇编的大侠帮忙。
[解决办法]

引用:

#include "stdio.h"
#include <iostream>

using namespace std;
class A{
public:
~A(){cout << "xigou"<< endl;}
};

main(){
A* a = new A();
a->~A();
a->~A();
a->~A();

getchar();
delete a;……

还有个问题...之所以导致大家跟你口水，你的问题没提明确啊................
我们现在研究的是析构函数调用之后对象的状态，但是你的问题没有明确指出，导致大家误解，
就像我刚才那段代码，我去研究析构函数执行之后对对象内部数据的影响而非对象本身了，
再商议商议
[解决办法]
避免去过问任何语言细节，除非必要。

实践中手动调用析构函数的真没怎么见过。。。

你们的讨论 很蛋疼。。。
[解决办法]

引用:

我现在只剩一个问题，楼主你年龄多大了？

从LZ的说话方式和喷人自信度判断，LZ不是90后
[解决办法]
实践出真理，看如下代码运行结果，你懂的

#include <iostream>

using namespace std;

class A
{
private:
int num;
public:
A()
{
}
~A()
{
cout<<"~A() is called"<<endl;
cout<<"num="<<num<<endl;
}
void SetNum(int value)
{
num=value;
}
int GetNum(void)
{
return num;
}
};


int main(void)
{
A *a=new A();
a->SetNum(100);

a->~A(); //1

a->~A(); //2

delete a; //3

a->~A(); //4

return 0;
}

运行结果：
~A() is called //1
num=100
~A() is called //2
num=100
~A() is called //3
num=100
~A() is called //4
num=-572662307
[解决办法]

引用:

引用:
实践出真理，看如下代码运行结果，你懂的

#include <iostream>

using namespace std;

class A
{
private:
int num;
public:
A()
{
}
~A()
{
cout<<"~A() is called"<<endl;
cout<<"num="<<num……

是啊 这说明了 手动调用析构函数 对象本身是不会被销毁的 自动调用就会
[解决办法]
析构不进行内存回收，delete进行了内存回收，sy4238是这个意思吧
[解决办法]
我还以为我得出的结论有问题哦 谢谢