对象特性

构造函数和析构函数

构造函数：创建对象时为对象的成员属性赋值

没有返回值也不写void
可以有参数，可以重载

析构函数：清理工作

无参数，不可重载
没有返回值也不写void

class MyClass
{
public:
    MyClass();
    ~MyClass();
private:
};

MyClass::MyClass()
{
}
MyClass::~MyClass()
{
}

构造函数的分类及调用

分类

有参构造
无参构造
普通构造
拷贝构造

class Person
{
public:
    int age;
    Person(const Person &p); //拷贝构造函数
};

Person::Person(const Person &p)
{
    age = p.age;
}

调用

//1. 括号法
Person p1;
Person p2(10);
Person p3(p2);  //拷贝构造函数调用

//注意事项
//调用默认构造函数时，不要加()
//因为下面这行代码，编译器会认为是一个函数的声明,不会认为在创建对象
Person p1();
void func();


//2. 显示法
Person p2 = Person(10); 
//Person(10) 匿名对象，当前行执行结束后，系统会立刻回收掉匿名对象

//注意
//不要用拷贝构造函数初始化匿名对象
Person(p3); //编译器会认为是 Person(p3) == Person p3;


//3. 隐式转换法
Person p4 = 10; //== Person p4 = Person(10);
Person p5 = p3;

拷贝构造函数调用时机

使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值

void doWork(Person p) //将对象作为值传递参数
{

}
void test02()
{
    Person p1;
    doWork(p1); //将对象作为值传递参数
}

值的方式返回局部对象

Person doWork()
{
    Person p1;
    return p1;  //局部变量p1实际在函数执行结束后会被释放
                //这里返回的，其实是拷贝了一个对象(p1)
}

void test03()
{
    Person p = doWork();
}

构造函数调用规则

默认情况下啊，C++编译器至少给一个类添加3个函数

默认构造函数(无参，函数体为空)
默认析构函数(无参，函数体为空)
默认拷贝构造函数，对属性进行值拷贝

如果我们提供了拷贝构造函数，编译器就不再为我们提供默认构造函数。

如果我们提供了构造函数，编译器还是为我们提供拷贝构造函数。

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝

深拷贝：在堆区重新申请空间，进行拷贝操作

利用编译器提供的拷贝构造函数，会做浅拷贝。

void test01()
{
    Person p1(12);
    cout << "p1的年龄: " << p1.m_age << endl;

    Person p2(p1); //默认的拷贝构造函数,编译器为我们做的浅拷贝
    cout << "p2的年龄: " << p2.m_age << endl;

}

class Person
{
public:
    int m_age;
    int *m_Height;
    Person();
    Person(int age,int height);
    ~Person();
};
Person::Person()
{
    cout << "默认构造函数" << endl;
}
Person::Person(int age,int height)
{
    cout << "有参构造函数" << endl;
    m_Height = new int(height);
    m_age = age;
}
Person::~Person()
{
    //析构代码，将堆区开辟的数据释放
    if (m_Height != NULL)
    {
        delete m_Height;
        m_Height = NULL;//防止野指针
    }
    cout << "析构函数" << endl;

}
void test01()
{
    Person p1(12,160);
    cout << "p1的年龄: " << p1.m_age << endl;
    cout << "p1的身高: " << *p1.m_Height << endl;
    Person p2(p1); //默认的拷贝构造函数,编译器为我们做的浅拷贝
    cout << "p2的年龄: " << p2.m_age << endl;
    cout << "p2的身高: " << *p2.m_Height << endl;
}
int main()
{
    test01();
    system("pause");
    return 0;
}

在栈区，先创建p1,再创建p2,释放的时候先释放p2，在执行析构函数的时候，p2已经将p2.m_Height 释放，而p1执行析构函数的时候，又回去释放该堆区空间，造成非法操作。

浅拷贝带来的问题：堆区的内存重复释放。

浅拷贝的问题利用深拷贝来解决。

自己实现拷贝构造函数，解决浅拷贝带来的问题。

Person::Person(const Person &p)
{
    cout << "Person 拷贝构造函数" << endl;
    m_age = p.m_age;//这行代码没有问题
    //m_Height = p.m_Height; 编译器默认实现就是这行代码
    //深拷贝
    m_Height = new int(*p.m_Height);
}

如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。

初始化列表

初始化属性

//传统的初始化操作
Person::Person(int a, int b, int c)
{
    m_A = a;
    m_B = b;
    m_C = c;
}

//初始化列表构造函数
Person::Person(int a, int b, int c) 
    :m_A(a), m_B(b), m_C(c)
{

}

类对象作为类成员

C++类的成员可以是另一个类的对象，称该成员为对象成员。

class Phone
{
public:
    string m_PName;
    Phone(string pName)
    {
        m_PName = pName;
        cout << "phone初始化" << endl;
    }
    ~Phone()
    {
        cout << "phone析构" << endl;
    }
};

class Person
{
public:
    string m_Name;
    Phone phone;
    Person(string Name, string pName):m_Name(Name),phone(pName)
    {
        cout << "Person初始化" << endl;
    }
    ~Person()
    {
        cout << "Person析构" << endl;
    }
};
void test()
{
    Person p1("zhangsan", "nokia");
}
int main()
{
    test();
    system("pause");
    return 0;
}

// phone 先初始化
// Person 后初始化

// 先构造成员对象，再构造自身
// 先析构自身，再析构成员对象

静态成员函数

所有对象共享一个函数

静态成员函数只能访问静态成员变量

#include 
#include 
#include 
using namespace std;

class Person
{
public:
    static int num;
    static void func()
    {
        cout << "static void func :" << num << endl;
    }

};

int Person::num = 100;

void test01()
{
    //通过对象调用

    //通过类名调用
    Person::func();
}

int main()
{
    test01();
    system("pause");
    return 0;
}

成员变量和成员函数是分开存储的

C++编译器会给每个空对象分配一个字节空间，是为了区分空对象占内存的位置

每个空对象也应该有一个独一无二的内存地址

// 非静态成员变量，属于类的对象
// 静态成员变量 类内声明，类外赋值

class Person
{
public:
    int m_A;
    static int m_B;

};
int Person::m_B = 100;

// 静态成员变量，不属于类的对象

this指针

this 的本质是指针常量

链式编程思想

class Person
{
public:
    int m_Age;
    Person(int age);
    Person& addAge();

};
Person::Person(int age):m_Age(age)
{
}
Person& Person::addAge() {
    this->m_Age += 10;
    return *this;   //指向本体
}

int main()
{
    Person p1(10);
    p1.addAge().addAge().addAge().addAge().addAge();
    cout << "Age of p: " << p1.m_Age << endl;

    system("pause");
    return 0;
}

空指针访问成员函数

C++中空指针也是可以调用成员函数的，凡是要注意有没有用到this指针。

如果用到this指针，需要加以判断保证代码的健壮性。

class Person
{
public:
    int m_Age;
    void showClassName()
    {
        cout << "this is Person" << endl;
    }
    void showPersonAge()
    {
        if (this == NULL)
        {
            return; //这样就不会崩了
        }
        cout << "age = " << m_Age << endl;
    }
};
void test01()
{
    Person *p1 = NULL;
    p1->showClassName(); //不会崩
    p1->showPersonAge(); //会崩 
}

const修饰成员函数

常函数

成员函数后加 const 我们称其为常函数

常函数内不允许修改成员属性

成员属性声明是加关键字 mutable 后，在常函数中依然可以修改。

class Person
{
public:
    int m_Age;

    mutable int m_B; //
    void showPerson() const //常函数
    {
        //const Person * const this;
        //在成员函数后面加 const，修饰的是this指针，让this指针指向的对象也不可以修改
        m_B = 100;
    }
};

常对象

声明对象前加const，常对象只能调用常函数。

const Person p; //常对象
//p.m_Age = 100; 不允许修改
p.m_B = 100; //加mutable关键字可以修改