构造函数与析构函数

构造函数与析构函数

浅拷贝：拷贝一赋值给另一个对象
深拷贝：指针地址重新开辟、再进行赋值
如果成员变量包含指针、一定完成深拷贝

深拷贝
避免自赋值 （if） 、释放旧空间、开辟新空间、赋值、返回*this

今天内容
构造函数：对创建的对象进行初始化。可重载。没有返回类型。返回的都是类的对象。
拷贝构造函数
析构函数
我们在类中定义了⼀一个构造函数,编译器不再提供默认构造函
数,这样在调用时可能出现错误,所以,这时我们也应该定义⼀一个默认构造函数;
拷贝构造函数：通过一个已经存在的对象来创建新对象（构造函数的参数是一个对象）Circle(const Circle &c)
编写过程：开辟空间、赋值 注意：拷贝构造函数的参数必须是一个引用（避免循环调用）
引用不会创建新对象，节省空间
**拷贝构造函数的调用情况
1.用一个对象初始化另一个对象 class Objcet(other_Objet);
class objcet=other xobjcet;//拷贝构造函数
class object; object=other object;//赋值运算符
2.函数参数以值传递的形式，实参赋值给形参，调用拷贝构造函数
void func(person p){…….}
func(object);
3.函数值返回形式返回一个对象，返回值会调用拷贝构造函数创建一个临时对象用来使用**
person function（){
person p；
return p;
} VC 测试

如果成员变量包含指针，源程原必须实现三个函数：拷贝构造，析构函数，赋值运算符重载
析构函数，先定义的变量后析构，后定义的变量先析构

构造函数和析构函数的调用

#include <iostream>
using namespace std;
class Person{
    friend ostream& operator<<(ostream& out,const Person& p);
public:
    Person(){
        //this->name=new char[20];
        this->name=NULL;
    }
    Person(char *_name,int _age){
        this->name=new char[strlen(_name)+1];
        strcpy(name,_name);
        age=_age;
        cout<<"普通构造函数"<<endl;
    }
    Person(Person &p){
        this->name=new char[strlen( p.name)+1];
        strcpy(this->name,p.name);
        this->age=p.age;
        cout<<"调用拷贝构造函数"<<endl;
    }
    ~ Person();
    Person& operator=(const Person& p);

private:
    char *name;
    int age;
};
Person::~ Person(){
    if(this->name!=NULL)
    {
        delete [] name;
        name=NULL;
    }
}

ostream& operator<<(ostream& out,const Person& p){
    out<<p.name<<endl;
    out<<p.age<<endl;
    out<<"______________________"<<endl;
    return out;
}

Person&  Person:: operator=(const Person& p){
    if(this!=&p){
        if(this->name!=NULL)
        { delete [] this->name;}
        this->name=new char [strlen(p.name)+1];
        strcpy(this->name,p.name);
        this->age=p.age;

    }
        return  *this;
}
void func(Person p){}
int main(int argc, const char * argv[]) {
    Person p1((char*)"shangguan",20);//普通构造函数调用
    cout<<p1<<endl;
    Person  p2=p1;//拷贝构造函数

    cout<<p2<<endl;
    Person  p3(p1);//调用拷贝构造函数
    cout<<p3<<endl;
//    Person  p4;
//    p4=p1;//调用普通构造函数
//   
//    cout<<p4<<endl;
//    p2=p1;
//    cout<<p1<<endl;
//    cout<<p2<<endl;

    func(p3);

    std::cout << "Hello, World!\n";
    return 0;
}

构造函数和类型转换：当构造函数只有一个人参数，可以做转换工作。

#include <iostream>
using namespace std;
class Person{
public:
    Person (char *_name){
        name=new char [strlen(_name)+1];
        strcpy(name,_name);
    }
    char* getName()const{
        return name;
    }
private:
    char *name;
};
void print(const Person &p){
        cout<<p.getName()<<endl;
    }


int main(){
    Person p1((char*)"sdfsa");
    print(p1);

    print((char*)"asdsaf");//类型转换
    Person p2="hello";
    print(p2);
     Person  array[]={(char*)"sdfsa”,(char*)"asdsaf”}//默认类型转换
}