构造函数与析构函数

构造函数：

        是一种特殊的成员函数，构造函数名与类名一样，没有返回值类型，也没有返回值,构造函数可以重载

        创建对象时初始化对象--为对象的成员变量赋初值

        在创建一个新对象时，系统会自动调用构造函数，如果没有显示给出构造函数，系统回自动给一个无参的构造函数。

        const在c语言中申明变量为只读不能直接修改的变量，在C++中申明一个常量

        不能在构造函数中赋值的可以使用成员初始化列表给数据成员赋值(实现构造函数时)

class MyClass {
 
public:
    //MyClass() {
    //    cout << "构造函数 = " << endl;
    //}//内联函数
    MyClass();
    MyClass(int val);
    const string  id;
    void setVal(int val);
private:
    string nane;
protected :
};
 
MyClass::MyClass() :id( "123") {
    cout << "构造函数 = " << id << endl;
}
 
 MyClass::MyClass(int val):id("999") {
     cout << "构造函数 = " << id << endl;
 }
 
void MyClass::setVal(int val) {
    cout << " vasl = " << val << endl;
}
 
int main()
{
    MyClass obj;
    MyClass obj1(5);
    obj.setVal(9);
 
    MyClass *p1 = new MyClass;
    MyClass *p2 = new MyClass(5);
 
    return 0;
}

析构函数：

        是一种特殊的成员函数，主要作用是在对象生命周期结束时进行清理，系统可以自动调用调用析构函数

        函数名与类名相同，使用~。没有返回值类型和返回值，也没有参数，是公有属性

        没有写时，系统回自动给出默认的析构函数

        析构函数可以通过对象主动调用，在系统生命周期结束时，会自动调用析构函数

        不是调用析构函数导致对象生命周期结束，而是生命周期结束会自动调用析构函数

        先构造的后析构

拷贝构造函数：（拷贝构造-函数）

        是一个特殊的构造函数，通过拷贝构造函数完成一个复制的过程。第一个参数是本类对象的引用，后面可以加参数列表

        先是构造函数，才可能是拷贝构造函数，可以使用系统默认，也可以自己定义

        调用时机：使用一个对象给另一个对象初始化，MyClass x3 = x；

                          使用一个对象构造另一个对象，MyClass x4 ( x);

                          函数的参数是类的对象

                          函数的返回值是类的对象

        深拷贝（自己声明了一块内存）与浅拷贝（默认拷贝）

        防止默认拷贝发生：写一个私有的拷贝构造函数，但不对他进行定义（主动让程序报错

class MyClass
{
public:
    MyClass();
    MyClass(int val,string name);
    ~MyClass();
 
    MyClass(const MyClass& obj);
    MyClass(const MyClass& obj, int n, int m);
 
public:
    int m;
    string str;
private:
 
};
 
MyClass::MyClass()
{
    m = 8797;
    str = "dsfhisdjfyhsd";
    cout << "无参构造函数 = " << m << "--------" << str << endl;
}
 
MyClass::MyClass(int val, string name):m(66),str("zh")
{
    cout << "有参构造函数 = " << val << "--------" << name << "--------"<< m << "--------" << str << endl;
}
 
MyClass::~MyClass()
{
    cout << "析造函数 = " << endl;
}
 
MyClass::MyClass(const MyClass& obj)
{
    m = obj.m;
    str = obj.str;
    cout << "拷贝构造函数 = " << m <<"--------" << str << endl;
}
 
MyClass::MyClass(const MyClass& obj,int dsf,int dfgd)
{
    m = obj.m;
    str = obj.str;
    cout << "拷贝构造函数 = " << m << "--------" << str<<"--------" << dsf<<"--------" << dfgd << endl;
}
void test1(MyClass obj) {
}
 
MyClass test2() {
 
#if 0
    MyClass sdfg;
    return sdfg;
#else 
    return MyClass();
#endif
}
 
 
 
 
    MyClass x;
    MyClass x2(8888,"ddsfhksdh");
    cout << " --------------------- " << endl;
    MyClass x3 = x;//使用一个对象给另一个对象初始
    MyClass x4 ( x);//使用一个对象构造另一个对象
    MyClass x5(x,657,4355);
    test1(x2);// 函数的参数是类的对象
    test1(x);// 函数的参数是类的对象
    test2();//函数的返回值是类的对象
 
 
    MyClass dfhgf = test2();

）