C++基础（二）

*最是人间留不住，朱颜辞镜花辞树。

一、类/对象

1.1 类和对象的区别

类是一个模板，是对一类事物的抽象描述；
对象是类的具体化、实例，由属性和方法组成；

例：将汽车抽象为一个类，那么奔驰、宝马…就是一个个对象。

1.2 属性和方法

属性相对静态，例如 汽车的长、宽、高；
方法相对动态，例如 汽车的启动、刹车停止。

2.1 类的封装

封装类就是给类添加访问权限：public、private、protected

2.2 类对象的内存尺寸

类对象的内存大小只与类中非静态属性相关，与静态属性及成员函数不相关。
按照内存对齐规则。

二、构造函数/析构函数

构造函数是类中的特殊成员函数，函数名与类名相同，没有返回值，构造函数由编译器自动调用。其重要意义是完成对类对象的初始化。
析构函数当对象被销毁前由编译器自动调用。
析构函数也称之为清理函数。有了析构函数，在析构函数中书写回收类对象中有属性指针指向堆区的资源，这样可以避免内存泄漏。

三、类中属性初始化

1、构造函数中初始化；
2、初始化列表（从右往左依次）
当类中有自定义类对象，类对象没有默认构造时，也必须在构造函数的初始化列表中进行指定。
const 修饰的必须在初始化列表中初始化。
3、静态属性在类外全局区初始化。

四、this指针

1.this第一种作用：当成员函数的形参变量名与类中属性变量名相同，加于区分。
2.this第二种作用：返加本对象 *this;

五、常函数/常函数

六、拷贝构造函数

Stu(const Stu& other)
{
    this->name = other.name;
    this->age = other.age;
    //this->p = other.p;
    //升级深拷贝的过程：
    //1.开辟一块新的同样大小的堆区空间。
    this->p = new int[1024];
    //2.通过memcpy或memmove拷贝原空间中的数据。
    memcpy(this->p,other.p,sizeof(int[1024]));
    cout << "Stu的拷贝构造" << endl;
}

1.使用其它已经定义好（已存在的）对象为本对象（正在构造的）进行初始化时，自动调用拷贝构造。
2.当函数形参为类类型时，会自动调用拷贝构造
3.当函数返回值类型为自定义类类型时，自动调用拷贝构造：
强调：当函数传参，或函数返回值返回时，推荐大家使用使用引用，来避免无意义的拷贝过程：（如果想要保护数据的安全，可以使用const再加以修饰。）

单例

1、饿汉式

#include <iostream>
using namespace std;
class Singleton
{
private:
    //1.把构造函数私有化。
    Singleton()
    {
        cout << "Singleton构造" << endl;
    }
    //4.在类的内部定义一个私有的本实例的指针,并升级为静态属性。
    static Singleton* myInstance;
public:
    //2.设定一个公有接口返回一个实例。
    //3.把这个公有的返回实例的接口升级为static修饰的成员函数。
    static Singleton* getInstance()
    {
        return myInstance;
    }
    
    //C++11所提供的关键字delete
    Singleton(const Singleton& other) = delete;
    void operator=(const Singleton& other) = delete ;
};
//5.类外完成静态单例指针的初始化。这种在类外直接获取一个对象实例的方式也叫饿汉式。
Singleton* Singleton::myInstance = new Singleton();
//饿汉是线程安全。


int main()
{
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    Singleton* s3 = Singleton::getInstance();

    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;

    return 0;
}

2、懒汉式

#include <iostream>
#include <mutex>
using namespace std;
mutex mtx;
class Singleton
{
private:
    //1.把构造函数私有化。
    Singleton()
    {
        cout << "Singleton构造" << endl;
    }
    //4.在类的内部定义一个私有的本实例的指针,并升级为静态属性。
    static Singleton* myInstance;
public:
    //2.设定一个公有接口返回一个实例。
    //3.把这个公有的返回实例的接口升级为static修饰的成员函数。
    static Singleton* getInstance()
    {
        //C++11提供的智能锁：
        lock_guard<mutex> lock(mtx);
        if(myInstance == nullptr)
        {
            myInstance = new Singleton();


        }
        return myInstance;
    }
    //在懒汉设计模式中，如果要释放对象时，请书写一个单独的普能函数来释放本对象的指针指向堆上空间。
    void destroy()
    {
        delete myInstance;
    }
    //C++11所提供的关键字delete
    Singleton(const Singleton& other) = delete;
    void operator=(const Singleton& other) = delete ;
};
//5.类外完成静态单例指针的初始化。
Singleton* Singleton::myInstance = nullptr;
int main()
{
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    Singleton* s3 = Singleton::getInstance();    
    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;
    s1->destroy();
    return 0;
}