各位高手，我的程序如下，如果没有析构函数(红色文字)就能正常运行，如果加上析构函数，就不能正常运行。请问为什么？如果要用析构函数的话，应该怎么写代码。谢谢!
#include<iostream.h>
#include<string.h>

class Person
{
private:
    char* name;
    int age;
    char* gender;
public:
    Person(){}
    Person(const char *name_t,const int age_t,const char *gender_t);
    Person(Person& person);
    void setName(const char *name_t);
    void setAge(const int age_t);
    void setGender(const char *gender_t);
    char* getName();
    int getAge();
    char* getGender();
    void display();
    ~Person()
    {
        delete[] name;
        delete[] gender;
    }
};
Person :: Person(const char *name_t,const int age_t,const char *gender_t)
{
    name = new char[strlen(name_t) + 1];
    strcpy(name,name_t);
    gender = new char[strlen(gender_t) + 1];
    strcpy(gender,gender_t);
    age = age_t;
}
Person :: Person(Person& person)
{
    name = new char[strlen(person.name) + 1];
    strcpy(name,person.name);
    gender = new char[strlen(person.gender) + 1];
    strcpy(gender,person.gender);
    age = person.age;   
}

void Person::setName(const char* name_t)
{
    name = new char[strlen(name_t) + 1];
    strcpy(name,name_t);
}
void Person ::setAge(const age_t)
{
    age = age_t;
}
void Person :: setGender(const char* gender_t)
{
    gender = new char[strlen(gender_t) + 1];
    strcpy(gender,gender_t);
}
char* Person :: getName()
{
    return name;
}
int Person :: getAge()
{
    return age;
}
char* Person :: getGender()
{
    return gender;
}
void Person :: display()
{
    cout << name << " | " << age << " | " << gender << endl;
}

//建立类模板Relation,该类模板生成的模板类由参数K、T决定。
template <class K,class T>
class Relation
{
private:
    K key;
    T value;
public:
    Relation(){}
    Relation(const K& k,const T& v)
    {
        key = k;
        value = v;
    }
    K getKey()
    {
        return key;
    }
    T getValue()
    {
        return value;
    }
    void setKey(const K& k)
    {
        key = k;
    }
    void setValue(const T& v)
    {
        value = v;
    }
};
//在主函数中测试
int main()
{
    Relation<char* ,Person> r;
    r.setKey("CEO");
    Person person("张三",40,"男");
    r.setValue(person);
    cout << r.getKey() <<" : ";
    r.getValue().display();
    return 0;
}

#include<iostream.h>
#include<string.h>

class Person
{
private:
    char* name;
    int age;
    char* gender;
public:
    Person(){}
    Person(const char *name_t,const int age_t,const char *gender_t);
    Person(Person& person);
    void setName(const char *name_t);
    void setAge(const int age_t);
    void setGender(const char *gender_t);
    char* getName();
    int getAge();
    char* getGender();
    void display();
    ~Person()
    {
      //delete[] name;
      //delete[] gender;
    }   
};
Person :: Person(const char *name_t,const int age_t,const char *gender_t)
{
    name = new char[strlen(name_t) + 1];
    strcpy(name,name_t);
    gender = new char[strlen(gender_t) + 1];
    strcpy(gender,gender_t);
    age = age_t;
}
Person :: Person(Person& person)
{
    name = new char[strlen(person.name) + 1];
    strcpy(name,person.name);
    gender = new char[strlen(person.gender) + 1];
    strcpy(gender,person.gender);
    age = person.age;
   
}

void Person::setName(const char* name_t)
{
    name = new char[strlen(name_t) + 1];
    strcpy(name,name_t);
}
void Person ::setAge(const age_t)
{
    age = age_t;
}
void Person :: setGender(const char* gender_t)
{
    gender = new char[strlen(gender_t) + 1];
    strcpy(gender,gender_t);
}
char* Person :: getName()
{
    return name;
}
int Person :: getAge()
{
    return age;
}
char* Person :: getGender()
{
    return gender;
}
void Person :: display()
{
    cout << name << " | " << age << " | " << gender << endl;
}

//建立类模板Relation,该类模板生成的模板类由参数K、T决定。
template <class K,class T>
class Relation
{
private:
    K key;
    T value;
public:
    Relation(){}
    Relation(const K& k,const T& v)
    {
        key = k;
        value = v;
    }
    K getKey()
    {
        return key;
    }
    T getValue()
    {
        return value;
    }
    void setKey(const K& k)
    {
        key = k;
    }
    void setValue(const T& v)
    {
        value = v;
    }
};
//在主函数中测试
int main()
{
    Relation<char* ,Person> r;
    r.setKey("CEO");
    Person person("张三",40,"男");
    r.setValue(person);
    cout << r.getKey() <<" : ";
    r.getValue().display();
    return 0;
}

红字里面不要就行了，析构函数会释放掉分配的内存的；

还有定义字符串类型的话，个人觉得很多地方用string来定义比用char好多了，可以减少很多累赘的代码！呵呵

/*
    重载赋值操作符，因为默认的赋值操作符起到的作用是两个指针指向同一块内存空间
    两个对象就有两个析构函数，同一块内存空间被delete两次，是会出问题的。
    */
    void operator= (const Person& o)
    {
        name = new char[strlen(o.name) + 1];
        strcpy(name,o.name);
        gender = new char[strlen(o.gender) + 1];
        strcpy(gender,o.gender);
        age = o.age; 
    }//在类体里加上后，能通过编译，运行正常。

感觉你的程序还会产生内存泄露，现在还不知道什么改。指向新内存应该把原先向的内存释放嘛

#include<iostream.h>
#include<string.h>
class Person
{
private:
    char* name;
    int age;
    char* gender;
public:
    Person():name(0),gender(0){}//这里最好把指针赋下值的
    Person(const char *name_t,const int age_t,const char *gender_t);
    Person(Person& person);
    void setName(const char *name_t);
    void setAge(const int age_t);
    void setGender(const char *gender_t);
    char* getName();
    int getAge();
    char* getGender();
    void display();
    void operator= (const Person& o)
    {
        name = new char[strlen(o.name) + 1];
        strcpy(name,o.name);
        gender = new char[strlen(o.gender) + 1];
        strcpy(gender,o.gender);
        age = o.age; 
    }
    ~Person()
    {
        delete[] name;
        delete[] gender;
    }
};
Person :: Person(const char *name_t,const int age_t,const char *gender_t)
{
    name = new char[strlen(name_t) + 1];
    strcpy(name,name_t);
    gender = new char[strlen(gender_t) + 1];
    strcpy(gender,gender_t);
    age = age_t;
}
Person :: Person(Person& person)
{
    //if(name != 0) delete [] name;我尝试着添上这么一句,结果会有运行错误……可能是因为是构造函数吧
    name = new char[strlen(person.name) + 1];
    strcpy(name,person.name);
    gender = new char[strlen(person.gender) + 1];
    strcpy(gender,person.gender);
    age = person.age; 
}
void Person::setName(const char* name_t)
{
    delete [] name;//释放原先的内存空间
    name = new char[strlen(name_t) + 1];
    strcpy(name,name_t);
}
void Person ::setAge(const age_t)
{
    age = age_t;
}
void Person :: setGender(const char* gender_t)
{
    delete [] gender;//释放原先的内存空间
    gender = new char[strlen(gender_t) + 1];
    strcpy(gender,gender_t);
}
char* Person :: getName()
{
    return name;
}
int Person :: getAge()
{
    return age;
}
char* Person :: getGender()
{
    return gender;
}
void Person :: display()
{
    cout << name << " | " << age << " | " << gender << endl;
}
//建立类模板Relation,该类模板生成的模板类由参数K、T决定。
template <class K,class T>
class Relation
{
private:
    K key;
    T value;
public:
    Relation(){}
    Relation(const K& k,const T& v)
    {
        key = k;
        value = v;
    }
    K getKey()
    {
        return key;
    }
    T getValue()
    {
        return value;
    }
    void setKey(const K& k)
    {
        key = k;
    }
    void setValue(const T& v)
    {
        value = v;
    }
};
//在主函数中测试
int main()
{
    Relation<char* ,Person> r;
    r.setKey("CEO");
    Person person("张三",40,"男");
    r.setValue(person);
    cout << r.getKey() <<" : ";
    r.getValue().display();
    return 0;
}

谢谢!明白了!