C++核心知识（三）—— 静态成员(变量、函数、const成员)、面向对象模型(this指针、常函数、常对象)、友元、数组类、单例模式

心上学事上练

已于 2023-03-06 21:22:15 修改

阅读量879

点赞数 2

分类专栏：【C++成长之路】文章标签： c++ 面向对象单例模式 Powered by 金山文档

于 2023-03-06 20:56:52 首次发布

本文链接：https://blog.csdn.net/u010217055/article/details/129362346

版权

【C++成长之路】专栏收录该内容

32 篇文章 26 订阅

订阅专栏

【上一篇】C++核心知识（二）—— 类和对象(类的封装)、对象的构造和析构(浅拷贝、深拷贝、explicit、动态分配内存)

1. 静态成员

在类定义中，它的成员（包括成员变量和成员函数），这些成员可以用关键字static声明为静态的，称为静态成员。

不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享。

1.1 静态成员变量

在一个类中，若将一个成员变量声明为static，这种成员称为静态成员变量。与一般的数据成员不同，无论建立了多少个对象，都只有一个静态数据的拷贝。静态成员变量，属于某个类，所有对象共享。

静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。

静态成员变量必须在类中声明，在类外定义。

静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间。

静态数据成员可以通过类名或者对象名来引用。

class Person{
public:
    //类的静态成员属性
    static int sNum;
private:
    static int sOther;
};

//类外初始化，初始化时不加static
int Person::sNum = 0;
int Person::sOther = 0;
int main(){


    //1. 通过类名直接访问
    Person::sNum = 100;
    cout << "Person::sNum:" << Person::sNum << endl;

    //2. 通过对象访问
    Person p1, p2;
    p1.sNum = 200;

    cout << "p1.sNum:" << p1.sNum << endl;
    cout << "p2.sNum:" << p2.sNum << endl;

    //3. 静态成员也有访问权限，类外不能访问私有成员
    //cout << "Person::sOther:" << Person::sOther << endl;
    Person p3;
    //cout << "p3.sOther:" << p3.sOther << endl;

    system("pause");
    return EXIT_SUCCESS;
}

1.2 静态成员函数

在类定义中，前面有static说明的成员函数称为静态成员函数。静态成员函数使用方式和静态变量一样，同样在对象没有创建前，即可通过类名调用。静态成员函数主要为了访问静态变量，但是，不能访问普通成员变量。

静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封装。

静态成员函数只能访问静态变量，不能访问普通成员变量

静态成员函数的使用和静态成员变量一样

静态成员函数也有访问权限

普通成员函数可访问静态成员变量、也可以访问非静态成员变量

class Person{
public:
    //普通成员函数可以访问static和non-static成员属性
    void changeParam1(int param){
        mParam = param;
        sNum = param;
    }
    //静态成员函数只能访问static成员属性
    static void changeParam2(int param){
        //mParam = param; //无法访问
        sNum = param;
    }
private:
    static void changeParam3(int param){
        //mParam = param; //无法访问
        sNum = param;
    }
public:
    int mParam;
    static int sNum;
};

//静态成员属性类外初始化
int Person::sNum = 0;

int main(){

    //1. 类名直接调用
    Person::changeParam2(100);

    //2. 通过对象调用
    Person p;
    p.changeParam2(200);

    //3. 静态成员函数也有访问权限
    //Person::changeParam3(100); //类外无法访问私有静态成员函数
    //Person p1;
    //p1.changeParam3(200);
    return EXIT_SUCCESS;
}

1.3 const静态成员属性

如果一个类的成员，既要实现共享，又要实现不可改变，那就用static const 修饰。定义静态const数据成员时，最好在类内部初始化。

class Person{
public:
    //static const int mShare = 10;
    const static int mShare = 10; //只读区
};
int main(){

    cout << Person::mShare << endl;
    //Person::mShare = 20;

    return EXIT_SUCCESS;
}

1.4 单例模式

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

Singleton（单例）：在单例类的内部实现只生成一个实例，同时它提供一个静态的getInstance()工厂方法，让客户可以访问它的唯一实例；为了防止在外部对其实例化，将其默认构造函数和拷贝构造函数设计为私有；在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例。

实现单例模式的思路:

1.把无参构造函数和拷贝构造函数私有化

2.定义一个类内的静态成员指针

3.在类外初始化时，new一个对象

4.把指针的权限设置为私有，然后提供一个静态成员函数让外面获取这个指针

用单例模式，模拟公司员工使用打印机场景，打印机可以打印员工要输出的内容，并且可以累积打印机使用次数。

class Printer{
public:
    //4.静态成员函数，访问静态成员变量
    static Printer* getInstance(){ return pPrinter;}
    void PrintText(string text){
        cout << "打印内容:" << text << endl;
        cout << "已打印次数:" << mTimes << endl;
        cout << "--------------" << endl;
        mTimes++;
    }
//1.把构造函数私有化（拷贝构造也要私有化）
private:
    Printer(){ mTimes = 0; }
    Printer(const Printer&){}
private:
    //2.定义一个类内的静态成员指针
    static Printer* pPrinter;
    int mTimes;
};
//3.在类外初始化时，new一个对象 
Printer* Printer::pPrinter = new Printer; //这里可以new是因为在Printer::作用域，编译器把它当成在类内

void test(){
    Printer* printer = Printer::getInstance();
    printer->PrintText("离职报告!");
    printer->PrintText("入职合同!");
    printer->PrintText("提交代码!");
}

2. C++面向对象模型初探

2.1 成员变量和函数的存储

在c语言中，变量和函数“分开来声明的，也就是说，语言本身并没有支持“数据”和“函数”之间的关联性我们把这种程序方法称为“程序性的”，由一组“分布在各个以功能为导航的函数中”的算法驱动，它们处理的是共同的外部数据。

c++实现了“封装”，那么数据(成员属性)和操作(成员函数)是什么样的呢？

“数据”和“处理数据的操作(函数)”是分开存储的。

c++中的非静态数据成员直接内含在类对象中，就像c struct一样。

成员函数(member function)虽然内含在class声明之内，却不出现在对象中。

每一个非内联成员函数(non-inline memberfunction)只会诞生一份函数实例。

class MyClass01{
public:
    int mA;
};

class MyClass02{
public:
    int mA;
    static int sB;
};

class MyClass03{
public:
    void printMyClass(){
        cout << "hello world!" << endl;
    }
public:
    int mA;
    static int sB;
};

class MyClass04{
public:
    void printMyClass(){
        cout << "hello world!" << endl;
    }
    static void ShowMyClass(){
        cout << "hello world！" << endl;
    }
public:
    int mA;
    static int sB;
};

int main(){

    MyClass01 mclass01;
    MyClass02 mclass02;
    MyClass03 mclass03;
    MyClass04 mclass04;

    cout << "MyClass01:" << sizeof(mclass01) << endl; //4
    //静态数据成员并不保存在类对象中
    cout << "MyClass02:" << sizeof(mclass02) << endl; //4
    //非静态成员函数不保存在类对象中
    cout << "MyClass03:" << sizeof(mclass03) << endl; //4
    //静态成员函数也不保存在类对象中
    cout << "MyClass04:" << sizeof(mclass04) << endl; //4

    return EXIT_SUCCESS;
}

空类的大小是1.

类的成员函数不占用类的大小，静态成员变量不占用类的大小，静态成员函数不占用类的大小

普通成员变量占用类的大小

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

2.2 this指针

2.2.1 this指针工作原理

通过上例我们知道，c++的数据和操作也是分开存储，并且每一个非内联成员函数(non-inlinemember function)只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。

那么问题是：这一块代码是如何区分那个对象调用自己的呢？

c++通过提供特殊的对象指针，this指针，解决上述问题。This指针指向被调用的成员函数所属的对象。

c++规定，this指针是隐含在对象成员函数内的一种指针。当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含指针this，用以保存这个对象的地址，也就是说虽然我们没有写上this指针，编译器在编译的时候也是会加上的。因此this也称为“指向本对象的指针”，this指针并不是对象的一部分，不会影响sizeof(对象)的结果。

this指针是C++实现封装的一种机制，它将对象和该对象调用的成员函数连接在一起，在外部看来，每一个对象都拥有自己的函数成员。一般情况下，并不写this，而是让系统进行默认设置。

this指针永远指向当前对象。

成员函数通过this指针即可知道操作的是那个对象的数据。This指针是一种隐含指针，它隐含于每个类的非静态成员函数中。This指针无需定义，直接使用即可。

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

c++编译器对普通成员函数的内部处理

2.2.2 this指针的使用

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

在类的非静态成员函数中返回对象本身，可使用return *this.

class Person{
public:
    //1. 当形参名和成员变量名一样时，this指针可用来区分
    Person(string name,int age){
        //name = name;
        //age = age; //输出错误
        this->name = name;
        this->age = age;
    }
    //2. 返回对象本身的引用
    //重载赋值操作符
    //其实也是两个参数，其中隐藏了一个this指针
    Person PersonPlusPerson(Person& person){
        string newname = this->name + person.name;
        int newage = this->age + person.age;
        Person newperson(newname, newage);
        return newperson;
    }
    void ShowPerson(){
        cout << "Name:" << name << " Age:" << age << endl;
    }
public:
    string name;
    int age;
};

//3. 成员函数和全局函数(Perosn对象相加)
Person PersonPlusPerson(Person& p1,Person& p2){
    string newname = p1.name + p2.name;
    int newage = p1.age + p2.age;
    Person newperson(newname,newage);
    return newperson;
}

int main(){

    Person person("John",100);
    person.ShowPerson();

    cout << "---------" << endl;
    Person person1("John",20);
    Person person2("001", 10);
    //1.全局函数实现两个对象相加
    Person person3 = PersonPlusPerson(person1, person2);
    person1.ShowPerson();
    person2.ShowPerson();
    person3.ShowPerson();
    //2. 成员函数实现两个对象相加
    Person person4 = person1.PersonPlusPerson(person2);
    person4.ShowPerson();

    system("pause");
    return EXIT_SUCCESS;
}

2.2.3 const修饰成员函数（常函数）

用const修饰的成员函数时，const修饰this指针指向的内存区域，成员函数体内不可以修改本类中的任何普通成员变量，

当成员变量类型符前用mutable修饰时例外。

//const修饰成员函数
class Person{
public:
    Person(){
        this->mAge = 0;
        this->mID = 0;
    }
    //在函数括号后面加上const,修饰成员变量不可修改,除了mutable变量
    void sonmeOperate() const{
        //this->mAge = 200; //mAge不可修改
        this->mID = 10; //const Person* const tihs;
    }
    void ShowPerson(){
        cout << "ID:" << mID << " mAge:" << mAge << endl;
    }
private:
    int mAge;
    mutable int mID;
};

int main(){

    Person person;
    person.sonmeOperate();
    person.ShowPerson();

    system("pause");
    return EXIT_SUCCESS;
}

2.2.4 const修饰对象(常对象)

常对象只能调用const的成员函数

常对象可访问 const 或非 const 数据成员，不能修改，除非成员用mutable修饰

class Person{
public:
    Person(){
        this->mAge = 0;
        this->mID = 0;
    }
    void ChangePerson() const{
        mAge = 100;
        mID = 100;
    }
    void ShowPerson(){
        cout << "ID:" << this->mID << " Age:" << this->mAge << endl;
    }

public:
    int mAge;
    mutable int mID;
};

void test(){    
    const Person person;
    //1. 可访问数据成员
    cout << "Age:" << person.mAge << endl;
    //person.mAge = 300; //不可修改
    person.mID = 1001; //但是可以修改mutable修饰的成员变量
    //2. 只能访问const修饰的函数
    //person.ShowPerson();
    person.ChangePerson();
}

2.2.5 拓展

this指针指向的空间有没有存储静态成员变量？

没有

this指针的指向可以改变吗？

this指针的指向不能改变，也就是说this是Person *const this;

防止空指针调用成员函数

class Person{
public:
    Person(){
        this->mAge = 0;
        this->mID = 0;
    }
   
    void ShowPerson(){
        if(this == NULL){
            cout << "this==NULL" << endl;
            return;
        }
        cout << "ID:" << this->mID << " Age:" << this->mAge << endl;
    }

public:
    int mAge;
    mutable int mID;
};

void test(){    
    Person* person = NULL;
    person->ShowPerson();
}

3. 友元

类的主要特点之一是数据隐藏，即类的私有成员无法在类的外部(作用域之外)访问。但是，有时候需要在类的外部访问类的私有成员，怎么办？

解决方法是使用友元函数，友元函数是一种特权函数，c++允许这个特权函数访问私有成员。这一点从现实生活中也可以很好的理解：

比如你的家，有客厅，有你的卧室，那么你的客厅是Public的，所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去，但是呢，你也可以允许你的闺蜜好基友进去。

程序员可以把一个全局函数、某个类中的成员函数、甚至整个类声明为友元。

3.1 友元语法

friend关键字只出现在声明处

其他类、类成员函数、全局函数都可声明为友元

友元函数不是类的成员，不带this指针

友元函数可访问对象任意成员属性，包括私有属性

class Building;
//友元类
class MyFriend{
public:
    //友元成员函数
    void LookAtBedRoom(Building& building);
    void PlayInBedRoom(Building& building);
};
class Building{
    //全局函数做友元函数
    friend void CleanBedRoom(Building& building);
#if 0
    //成员函数做友元函数
    friend void MyFriend::LookAtBedRoom(Building& building);
    friend void MyFriend::PlayInBedRoom(Building& building);
#else    
    //友元类
    friend class MyFriend;
#endif
public:
    Building();
public:
    string mSittingRoom;
private:
    string mBedroom;
};

void MyFriend::LookAtBedRoom(Building& building){
    cout << "我的朋友参观" << building.mBedroom << endl;
}
void MyFriend::PlayInBedRoom(Building& building){
    cout << "我的朋友玩耍在" << building.mBedroom << endl;
}

//友元全局函数
void CleanBedRoom(Building& building){
    cout << "友元全局函数访问" << building.mBedroom << endl;
}

Building::Building(){
    this->mSittingRoom = "客厅";
    this->mBedroom = "卧室";
}

int main(){

    Building building;
    MyFriend myfriend;

    CleanBedRoom(building);
    myfriend.LookAtBedRoom(building);
    myfriend.PlayInBedRoom(building);

    system("pause");
    return EXIT_SUCCESS;
}

友元类注意：

友元关系不能被继承。

友元关系是单向的，类A是类B的朋友，但类B不一定是类A的朋友。

友元关系不具有传递性。类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。

思考: c++是纯面向对象的吗？
如果一个类被声明为friend,意味着它不是这个类的成员函数，却可以修改这个类的私有成员，而且必须列在类的定义中，因此他是一个特权函数。c++不是完全的面向对象语言，而只是一个混合产品。增加friend关键字只是用来解决一些实际问题，这也说明这种语言是不纯的。毕竟c++设计的目的是为了实用性，而不是追求理想的抽象。

--- Thinking in C++

3.2 案例

请编写电视机类，电视机有开机和关机状态，有音量，有频道，提供音量操作的方法，频道操作的方法。由于电视机只能逐一调整频道，不能指定频道，增加遥控类，遥控类除了拥有电视机已有的功能，再增加根据输入调台功能。

提示：遥控器类可作为电视机类的友元类。

class Remote;

class Television{
    friend class Remote;
public:
    enum{ On,Off }; //电视状态
    enum{ minVol,maxVol = 100 }; //音量从0到100
    enum{ minChannel = 1,maxChannel = 255 }; //频道从1到255
    Television(){
        mState = Off;
        mVolume = minVol;
        mChannel = minChannel;
    }

    //打开电视机
    void OnOrOff(){
        this->mState = (this->mState == On ? Off : On);
    }
    //调高音量
    void VolumeUp(){
        if (this->mVolume >= maxVol){
            return;
        }
        this->mVolume++;
    }
    //调低音量
    void VolumeDown(){
        if (this->mVolume <= minVol){
            return;
        }
        this->mVolume--;
    }
    //更换电视频道
    void ChannelUp(){
        if (this->mChannel >= maxChannel){
            return;
        }
        this->mChannel++;
    }
    void ChannelDown(){
        if (this->mChannel <= minChannel){
            return;
        }
        this->mChannel--;
    }
    //展示当前电视状态信息
    void ShowTeleState(){
        cout << "开机状态:" << (mState == On ? "已开机" : "已关机") << endl;
        if (mState == On){
            cout << "当前音量:" << mVolume << endl;
            cout << "当前频道:" << mChannel << endl;
        }
        cout << "-------------" << endl;
    }
private:
    int mState; //电视状态，开机，还是关机
    int mVolume; //电视机音量
    int mChannel; //电视频道
};

//电视机调台只能一个一个的调，遥控可以指定频道
//电视遥控器
class Remote{
public:
    Remote(Television* television){
        pTelevision = television;
    }
public:
    void OnOrOff(){
        pTelevision->OnOrOff();
    }
    //调高音量
    void VolumeUp(){
        pTelevision->VolumeUp();
    }
    //调低音量
    void VolumeDown(){
        pTelevision->VolumeDown();
    }
    //更换电视频道
    void ChannelUp(){
        pTelevision->ChannelUp();
    }
    void ChannelDown(){
        pTelevision->ChannelDown();
    }
    //设置频道 遥控新增功能
    void SetChannel(int channel){
        if (channel < Television::minChannel || channel > Television::maxChannel){
            return;
        }
        pTelevision->mChannel = channel;
    }

    //显示电视当前信息
    void ShowTeleState(){
        pTelevision->ShowTeleState();
    }
private:
    Television* pTelevision;
};


//直接操作电视
void test01(){

    Television television;
    television.ShowTeleState();
    television.OnOrOff(); //开机
    television.VolumeUp(); //增加音量+1
    television.VolumeUp(); //增加音量+1
    television.VolumeUp(); //增加音量+1
    television.VolumeUp(); //增加音量+1
    television.ChannelUp(); //频道+1
    television.ChannelUp(); //频道+1
    television.ShowTeleState();
}

//通过遥控操作电视
void test02(){
    //创建电视
    Television television;
    //创建遥控
    Remote remote(&television);
    remote.OnOrOff();
    remote.ChannelUp();//频道+1
    remote.ChannelUp();//频道+1
    remote.ChannelUp();//频道+1
    remote.VolumeUp();//音量+1
    remote.VolumeUp();//音量+1
    remote.VolumeUp();//音量+1
    remote.VolumeUp();//音量+1
    remote.ShowTeleState();
}

4. 数组类封装

4.1 设计

目的：设计一个类，该类有数组的功能，可以存储数据，可以删除修改数据

设计核心数据：

属性：指针（指向堆区空间），数组实际存储的元素个数，数组容量

方法：构造（开辟堆区空间），尾插，头插，指定位置插入，尾删，头删，获取指定位置的值，指定位置修改值，获取数组元素个数，获取数组容量，析构函数

4.2 源码

MyArray.h

#ifndef MYARRAY_H
#define MYARRAY_H

class MyArray{
public:
    //无参构造函数，用户没有指定容量，则初始化为100
    MyArray();
    //有参构造函数，用户指定容量初始化
    explicit MyArray(int capacity);
    //用户操作接口
    //根据位置添加元素
    void SetData(int pos, int val);
    //获得指定位置数据
    int GetData(int pos);
    //尾插法
    void PushBack(int val);
    //获得长度
    int GetLength();
    //析构函数，释放数组空间
    ~MyArray();
private:
    int mCapacity; //数组一共可容纳多少个元素
    int mSize; //当前有多少个元素
    int* pAdress; //指向存储数据的空间
};

#endif

MyArray.cpp

#include"MyArray.h"

MyArray::MyArray(){
    this->mCapacity = 100;
    this->mSize = 0;
    //在堆开辟空间
    this->pAdress = new int[this->mCapacity];
}
//有参构造函数，用户指定容量初始化
MyArray::MyArray(int capacity){
    this->mCapacity = capacity;
    this->mSize = 0;
    //在堆开辟空间
    this->pAdress = new int[capacity];
}
//根据位置添加元素
void MyArray::SetData(int pos, int val){
    if (pos < 0 || pos > mCapacity - 1){
        return;
    }
    pAdress[pos] = val;
}
//获得指定位置数据
int MyArray::GetData(int pos){
    return pAdress[pos];
}
//尾插法
void MyArray::PushBack(int val){
    if (mSize >= mCapacity){
        return;
    }
    this->pAdress[mSize] = val;
    this->mSize++;
}
//获得长度
int MyArray::GetLength(){
    return this->mSize;
}
//析构函数，释放数组空间
MyArray::~MyArray(){
    if (this->pAdress != nullptr){
        delete[] this->pAdress;
    }
}

TestMyArray.cpp

#include"MyArray.h"

void test(){
    //创建数组
    MyArray myarray(50);
    //数组中插入元素
    for (int i = 0; i < 50; i++){
        //尾插法
        myarray.PushBack(i);
        //myarray.SetData(i, i);
    }
    //打印数组中元素
    for (int i = 0; i < myarray.GetLength(); i++){
        cout << myarray.GetData(i) << " ";
    }
    cout << endl;
}

【上一篇】C++核心知识（二）—— 类和对象(类的封装)、对象的构造和析构(浅拷贝、深拷贝、explicit、动态分配内存)

心上学事上练

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++核心知识（三）—— 静态成员(变量、函数、const成员)、面向对象模型(this指针、常函数、常对象)、友元、数组类、单例模式

在c语言中，变量和函数“分开来声明的，也就是说，语言本身并没有支持“数据”和“函数”之间的关联性我们把这种程序方法称为“程序性的”，由一组“分布在各个以功能为导航的函数中”的算法驱动，它们处理的是共同的外部数据。this指针是C++实现封装的一种机制，它将对象和该对象调用的成员函数连接在一起，在外部看来，每一个对象都拥有自己的函数成员。比如你的家，有客厅，有你的卧室，那么你的客厅是Public的，所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去，但是呢，你也可以允许你的闺蜜好基友进去。
复制链接

扫一扫