#include<iostream>
using namespace std;

class time{
public:
int second;
int min;
~time(){}
};

class Date{
public:
Date(int dd,int mm,int yy);
Date()
{
t = new time;
d = 1;
m = 1;
y = 2006;
t->min = 0;
t->second = 0;
t = NULL;
}

Date& add_year(int n){ y += n; return *this;}
Date& add_month(int n){ m += n; return *this;}
Date& add_day(int n) { d += n; return *this;}

~Date(){
delete t;
}

void display() const;
private:
/*mutable*/ int d,m,y;
static Date default_date;
time *t;

};

Date Date::default_date = Date();
inline Date::Date(int dd,int mm,int yy)
{

if(t==NULL) cout<<"yes"<<endl;
t = new time;
d = dd ? dd:default_date.d;
m = mm ? mm:default_date.m;
y = yy ? yy:default_date.y;
t->second = 12;
t->min = 32;
}

inline void Date::display() const
{
Date *ptod = const_cast<Date *>(this);
cout<<ptod->d+1 <<"/"<<ptod->m+1<<"/"<<ptod->y+1<<endl;
}

int main()
{
Date d(0,0,0);
d.display();
d.add_year(1).add_month(1).add_day(1);
d.display();
}

我想提醒大家的就是 time *t 已经在 Date Date::default_date = Date(); 中初始化(初试化时间是在进入main函数之前,也就是在定义Date的时候初始化的) 所以t不属于任何对象.
那么在定义了 对象d之后就调用Date(int dd,int mm,int yy),这个时候this指针是指向 对象d的,所以Date(int dd,int mm,int yy)里面的t是属于对象d的,那么如果企图想在Date(int dd,int mm,int yy)里面delete Date()里new分配的内寸单元就会出错
原因是t属于的对象不同,一个是属于无名对象,一个是属于d.

费了半天劲，终于搞点小懂了，原来是不同对象的指针~~

挖哈哈哈，这个问题如果不留意是很容易出错的

有点不明白，为什么对t进行了两次的内存分配而释放内存只有一次呢？？？？

类的非静态数据成员,是在类对象声明时分配的内存.

静态数据成员,在程序开始时就分配了.

这个程序,应该是在结束时析构了这个静态成员.

楼上的:
你前两句说对了，后面那句有点问题。因为在Date(int dd,int mm,int yy)中进行第二次分配的时候
t已经改变了指向，也就是指向了新的内存地址，也就是说旧的静态对象分配的内存已经丢失了。
当退出程序的时候，1。首先进行对象d的析构，那个时候t就指向随意的内存地址。2，进行静态对象的析构，但是由于这个时候t已经指向了随意的内存地址，发生析构的时候就会发生灾难性后果。
大家可以试下，但是试过之后下次就要注意不要再犯这个错误。

#include <iostream>
using namespace std;

class A
{
int *p;
static A obj;
static int counter;
public:
A();
~A();
};

int A::counter=0;
A A::obj;

A::A()
{
p=new int;
counter++;
cout<<"constructor "<<counter<<endl;

}
A::~A()
{
delete p;
cout<<"destructor "<<counter<<endl;
counter--;
}

int main()
{
A x;
A y;
A z;
return 0;
}

[此贴子已经被作者于2006-1-8 21:30:37编辑过]

哦,是我自己糊涂了,不要意思~~~搞来搞去都是指针所属的对象不同.

有指针和使用new的类确实有一些问题

因为默认复制构造函数 和默认赋值操作符 只对类数据成员简单复制

#include <iostream>
using namespace std;

class A
{
int *p;
static A obj;
static int counter;
public:
A();
~A();
};

int A::counter=0;
A A::obj;

A::A()
{
p=new int;
counter++;
cout<<"constructor "<<counter<<" p pointer point address : "<<p<<endl;

}
A::~A()
{
delete p;
cout<<"destructor "<<counter<<" p pointer point address : "<<p<<endl;
counter--;
}

int main()
{
A x;
A y;
y=x;
A z;
return 0;
}

泄漏啦

[此贴子已经被作者于2006-1-9 8:46:53编辑过]

对，所以在有指针成员的类一定要写上copy constructor　或者 重载 operator =运算符号，那就肯定不会再出现这些问题．还有在写上述函数的时候还要防止自复制
例如 if(this != &t) t是本类的对象．