C++类和对象（六）

day06

2023年3月10日

知识点1.单例模式设计

单例模式是一种常用的软件设计模式，在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

特点：①在单例内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例；

②提供一个静态的方法，让客户可以访问它的唯一实例；

③为了防止在外部对其实例化，将其默认构造函数和拷贝构造函数设计为私有。

#include <iostream>

using namespace std;

class Printer{
private:
    //1、定义一个静态的对象指针变量，保存唯一实例
    static Printer *singlePrint;
    //2、防止该类实例化其他对象，将构造函数全部私有化
    Printer(){count = 0;}
    Printer(const Printer &ob){}
public:
    //3、提供一个方法，获得单例指针
    static Printer* getSinglePrint()
    {
        return singlePrint;
    }
    //4、设置功能函数
    void printText(const char *str)
    {
        count ++;
        cout << "打印" << str << endl;
    }
    int count;//统计打印任务数量
};
Printer *Printer::singlePrint = new Printer;

int main()
{
    Printer *p1 = Printer::getSinglePrint();
    p1->printText("入职报告");
    p1->printText("体检报告");

    Printer *p2 = Printer::getSinglePrint();
    p2->printText("入职报告");
    p2->printText("体检报告");

    cout << "打印任务数量" << p2->count << endl;
    cout << (void *)p1 << endl;
    cout << (void *)p2 << endl;

    return 0;
}

结果：

知识点2.this指针

当一个对象调用方法（成员函数）时，会在方法中产生一个this指针，this指针指向所调用方法的对象，成员函数通过this指针即可指导操作的那个对象的数据；

注意：①this指针是一种隐含指针，它隐含于每个类的非静态成员函数中；

②this指针无需定义，直接使用即可；

③静态成员函数内部没有this指针，静态成员函数不能操作非静态成员变量。

应用：①当形参和成员变量同名时，可以用this指针来区分；

②利用*this在类的普通成员函数中返回对象本身

#include <iostream>

using namespace std;

class Test{
private:
    int num;
public:
    Test(int num){
        //将形参num的值赋值给类的成员变量num
        this->num = num;
    }
    int getNum(){
        return num;
    }
    Test& myCout(const char *str){
        cout << str;
        //利用*this返回对象本身
        return *this;
    }
};

int main()
{
    Test t1(10);
    cout << "t1.num = " << t1.getNum() << endl;

    t1.myCout("hello").myCout(" world");

    return 0;
}

结果：

知识点3.const修饰的成员函数和常对象

1、使用const修饰成员函数时，const修饰this指针指向的内存区域，成员函数体内不可以修改本类中的任何普通成员变量，当成员变量类型前使用mutable修饰时例外。

语法：返回值类型 成员函数名() const{ 函数体; }

2、常对象是指const修饰的对象，只能调用const修饰的成员函数，不能调用普通成员函数。

#include <iostream>

using namespace std;

class Data{
private:
    int data;
    mutable int num;
public:
    //const修饰成员函数
    void printData() const{
        //普通成员变量不允许修改
        //data = 100;//err
        //mutable修饰的成员变量可以修改
        num = 200;//ok
        cout << "data = " << data << ",num = " << num << endl;
    }
    //普通成员函数
    void setNum(int num){ this->num = num; }
    Data(){};
    Data(int data, int num){
        this->data = data;
        this->num = num;
        cout << "有参构造" << endl;
    }
    Data(Data &ob){
        this->data = ob.data;
        this->num = ob.num;
        cout << "拷贝构造" << endl;
    }
    ~Data(){ cout << "析构函数" << endl; }
};

int main()
{
    Data ob(10, 20);
    ob.printData();

    const Data ob1(30, 40);
    //调用const修饰的成员函数
    ob1.printData();//ok
    //因为普通成员函数有修改成员变量的可能，所以不允许调用普通成员函数
    //ob1.setNum(100);//err

    return 0;
}

结果：