【C++复习专题】—— 类和对象，包含类的引入、访问限定符、类的6个默认成员函数等

1.类的定义

class classname
{
    //类体：由成员函数和成员变量组成
}; 

        class为定义类的关键字，classname为类的名字，{}中为类的主体。

        类体中的内容称为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数。

类的两种定义方式：

        1.声明和定义全部放在类体内（当成员函数在类中定义，编译器会将其当成内联函数处理）

        2.声明和定义分开（在首先函数的定义时想要指定类名和命名空间）

2.类的访问限定符及封装

2.1 访问限定符

        1.public修饰的成员在类外可以直接被访问，protected和private修饰的成员在类外不能直接被访问

        2.访问权限作用域是从该访问限定符出现的位置开始直到下一个访问限定符出现为止，如果后面没有访问限定符，作用域就到}为止

        3.class的默认访问权限是private，struct为public

        4.protected与private的区别：如果父类由protected修饰和private修饰的成员那么通过public继承后子类可以访问protected修饰的成员而不能访问private修饰的成员

        注意：访问限定符只在编译时有用，当数据映射到内存后，没有如何访问限定符上的区别

2.2 封装

        面向对象的三大特性：封装、继承、多态

        封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来 和对象进行交互。

        封装本质上是一种管理，让用户更方便使用类。通俗解释封装其实就像我们玩的电脑一样，我们不需要知道电脑的CPU、显卡、内存等元件怎么工作，我们只需要通过键盘是、鼠标等设备就可以使用电脑。

3.类的作用域和实例化

3.1 类的作用域

        类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员时，想要使用：：（类作用限定符）指明成员属于那个类域。

class Person
{
public:
 void PrintPersonInfo();
private:
 char _name[20];
 char _gender[3];
 int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
 cout << _name << " "<< _gender << " " << _age << endl;
}

3.2 类的实例化

        用类类型创建对象的过程，称为类的实例化。

        类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没 有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个 类，来描述具体学生信息。又比如一个类含有模板参数，我们可以将这个类理解为一张图纸，我们对于模板参数取不同的类型可以创建出不同的对象，这些对象理解为通过图纸建造的房子。

        实例化出的对象 占用实际的物理空间，存储类成员变量

4.类对象的大小

        一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象

        结构体内存对齐规则

        1. 第一个成员在与结构体偏移量为0的地址处。

        2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

                注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

                VS中默认的对齐数为8

        3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

        4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

        说白了就是找类内（包括嵌套类）最大的变量将其与编译器默认对齐数比较取小的那个，就是我们的对齐数然后类的大小就是这个数的整数倍

5.this指针（重点）

5.1 this指针的引入

        我们先来定义一个日期类Date

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year; 
	int _month;
	int _day; 
};
int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	d2.Print();
	return 0;
}

        对于上述类，有这样的一个问题： Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函 数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

        C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏 的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

5.2 this指针的特性

        1.this指针的类型：类类型* const，即成员函数中，不能给this指针赋值

        2.this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

        3.this指针只能在“成员函数”的内部使用

        4.this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

5.3 c和c++实现Stack的对比

        C语言实现

typedef int DataType;
typedef struct Stack
{
	DataType* array;
	int capacity;
	int size;
}Stack;
void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (DataType*)malloc(sizeof(DataType) * 3);
	if (NULL == ps->array)
	{
		assert(0);
		return;
	}
	ps->capacity = 3;
	ps->size = 0;
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	if (ps->array)
	{
		free(ps->array);
		ps->array = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}
void CheckCapacity(Stack* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		DataType* temp = (DataType*)realloc(ps->array,
			newcapacity * sizeof(DataType));
		if (temp == NULL)
		{
			perror("realloc申请空间失败!!!");
			return;
		}
		ps->array = temp;
		ps->capacity = newcapacity;
	}
}
void StackPush(Stack* ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->size] = data;
	ps->size++;
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return 0 == ps->size;
}
void StackPop(Stack* ps)
{
	if (StackEmpty(ps))
		return;
	ps->size--;
}
DataType StackTop(Stack* ps)
{
	assert(!StackEmpty(ps));
	return ps->array[ps->size - 1];

}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->size;
}
int main()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));
	StackPop(&s);
	StackPop(&s);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));
	StackDestroy(&s);
	return 0;
}

        可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

       1. 每个函数的第一个参数都是Stack*

         2.函数中必须要对第一个参数检测，因为该参数可能会为NULL

        3.函数中都是通过Stack*参数操作栈的

        4.调用时必须传递Stack结构体变量的地址

        结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据 的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

        C++实现

typedef int DataType;
class Stack
{
public:
    void Init()
    {
        _array = (DataType *)malloc(sizeof(DataType) * 3);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = 3;
        _size = 0;
    }
    void Push(DataType data)
    {
        CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    void Pop()
    {
        if (Empty())
            return;
        _size--;
    }
    DataType Top() { return _array[_size - 1]; }
    int Empty() { return 0 == _size; }
    int Size() { return _size; }
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }

private:
    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            int newcapacity = _capacity * 2;
            DataType *temp = (DataType *)realloc(_array, newcapacity *
                                                             sizeof(DataType));
            if (temp == NULL)
            {
                perror("realloc申请空间失败!!!");
                return;
            }
            _array = temp;
            _capacity = newcapacity;
        }
    }

private:
    DataType *_array;
    int _capacity;
    int _size;
};
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);

    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Pop();
    s.Pop();
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Destroy();
    return 0;
}

        C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制这些方法在类外可以被调用，即封装在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。 而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack * 参数是编译器维护的，C语言中需用用户自己维护。

6. 类的6个默认成员函数

6.1 构造函数

6.1.1 概念

        对于以下Date类

class Date
{
public:
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;
    d1.Init(2022, 7, 5);
    d1.Print();
    Date d2;
    d2.Init(2022, 7, 6);
    d2.Print();
    return 0;
}

        对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置 信息，未免有点麻烦，所以构造函数就产生了，它可以帮助我们在对象创建时完成相应信息的设置。

        构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

6.1.2 特性

        构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象（通过初始化列表完成）。

其特征如下：

        1. 函数名与类名相同。

        2. 无返回值。

        3. 对象实例化时编译器自动调用对应的构造函数。

        4. 构造函数可以重载。

class Date
{
public:
    // 1.无参构造函数
    Date()
    {
    }
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        year = year;
        _month = month;
        _day = day;
    }

private:
    int _year;
    int _month;
    int _day;
};
void TestDate()
{
    Date d1;             // 调用无参构造函数
    Date d2(2015, 1, 1); // 调用带参的构造函数
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
    Date
    d3();
}

        注意：如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦 用户显式定义编译器将不再生成

        默认构造的作用体现在当类内成员变量包含自定义类型时，生成的默认构造会调用该自定义类型的构造函数完成对其的初始化。

        注意：

        1.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

        2.无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

6.1.3 构造函数初始化列表

        初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式

class Date
{
public:
    Date(int year, int month, int day)
        : _year(year), _month(month), _day(day)
    {
    }

private:
    int _year;
    int _month;
    int _day;
};

        注意：构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体 内可以多次赋值。

        注意：

        1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

        2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

               2.1 引用成员变量

                2.2 const成员变量

                2.3 自定义类型成员(且该类没有默认构造函数时）

6.1.4 隐式类型转换

        构造函数不仅可以构造与初始化对象，对于接收单个参数的构造函数，还具有类型转换的作用。

        接收单个参 数的构造函数具体表现：  

        1. 构造函数只有一个参数

        2. 构造函数有多个参数，除第一个参数没有默认值外，其余参数都有默认值

        3. 全缺省构造函数

class Date
{
public:
    // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
    // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
    explicit Date(int year)
        : _year(year)
    {
    }
    /*
    // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转
   换作用
    // explicit修饰构造函数，禁止类型转换
    explicit Date(int year, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
    {}
    */
    Date &operator=(const Date &d)
    {
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }

private:
    int _year;
    int _month;
    int _day;
};
void Test()
{
    Date d1(2022);
    // 用一个整形变量给日期类型对象赋值
    // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值d1 = 2023;
    // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作
    // 用
}

        注意：用explicit修饰构造函数，将会禁止构造函数的隐式转换。

6.2 析构函数

6.2.1 析构函数概念

        析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

6.2.2 析构函数特性

析构函数是特殊的成员函数，其特征如下：

        1. 析构函数名是在类名前加上字符 ~。

        2. 无参数无返回值类型。

        3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

        4. 对象生命周期结束时，C++编译系统系统自动调用析构函数

typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 3)
    {
        _array = (DataType *)malloc(sizeof(DataType) * capacity);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(DataType data)
    {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    // 其他方法...
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }

private:
    DataType *_array;
    int _capacity;
    int _size;
};
void TestStack()
{
    Stack s;
    s.Push(1);
    s.Push(2);
}

int main()
{
    TestStack();
    return 0;
}

        当我们不写析构函数时编译器自动生成的析构函数，对内置类型并没有什么作用，但是对于自定义类型成员会调用他的析构函数

class Time
{
public:
    ~Time()
    {
        cout << "~Time()" << endl;
    }

private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
    // 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d;
    return 0;
}

        程序运行结束后输出：~Time()

        因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,

        _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。

        但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数

        注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

6.3 拷贝构造函数

6.3.1 拷贝构造函数概念

        拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

6.3.2 拷贝构造函数特性

        拷贝构造函数也是特殊的成员函数，其特征如下：

        1. 拷贝构造函数是构造函数的一个重载形式。

        2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。

        3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

        注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定 义类型是调用其拷贝构造函数完成拷贝的。

6.3.3 拷贝构造函数典型调用场景

       1.使用已存在对象创建新对象

        2.函数参数类型为类类型对象

        3.函数返回值类型为类类型对象

class Date
{
public:
    Date(int year, int minute, int day)
    {
        cout << "Date(int,int,int):" << this << endl;
    }
    Date(const Date &d)
    {
        cout << "Date(const Date& d):" << this << endl;
    }
    ~Date()
    {
        cout << "~Date():" << this << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};
Date Test(Date d)
{
    Date temp(d);
    return temp;
}
int main()
{
    Date d1(2022, 1, 13);
    Test(d1);
    return 0;
}

6.4 赋值运算符重载

6.4.1 运算符重载

        函数名为：关键字operator + 需要重载的运算符符号

        函数原型：返回值类型 operator操作符 （参数列表）

注意：

        1.  .*    ::    sizeof    ?:     .  这5个运算符不能进行重载

        2. 用于内置类型的运算符，其含义不能改变。

        3.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐 藏的this

6.4.2 赋值运算符重载

 赋值运算符重载格式：

        参数类型：const T&，传递引用可以提高传参效率

        返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

        检测是否自己给自己赋值

        返回*this ：要复合连续赋值的含义

注意：赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    int _year;
    int _month;
    int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date &operator=(Date &left, const Date &right)
{
    if (&left != &right)
    {
        left._year = right._year;
        left._month = right._month;
        left._day = right._day;
    }
    return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

        原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值 运算符重载只能是类的成员函数

        用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注 意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符 重载完成赋值

        注意：如果类中未涉及到资源管理（就是malloc、realloc、new等动态内存），赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

        值得一提前置++的重载函数为   类型&  operator++（）

        后置++的重载函数为   类型& operator++ (int)  

        其实那个int只是为了区分前置和后置，因为编译器在完成编译时会对函数名进行处理g++下大致就是 函数名和参数类型来组成编译后的函数名，所以通过int可以区分前置和后置

6.5 取地址及const取地址操作符重载

        这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

7.static成员

        概念：声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

单例模式就是根据这个设计的。

class A
{
public:
    A(int a)
        : _a1(a), _a2(_a1)
    {
    }

private:
    int _a2;
    int _a1;
    static int _a;
};

int A::_a = 10;

       static成员特性

        1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

        2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

        3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

        4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

        5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制