第二章：类与对象（上）
2.1面向对象和面向过程的初步认识
1.C语言是面向过程的，关注的是过程，分析求出问题的步骤，通过函数调用逐步解决问题。
用洗衣服类比：
2.C++是基于面向对象（不是纯面向对象）的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间交互完成。
用洗衣服类比：
1）总共有四个对象：
人、衣服、洗衣粉、洗衣机。
2）整个洗衣服的过程：
人将衣服放进洗衣机，倒入洗衣粉，启动洗衣机，洗衣机就会完成洗衣过程并且甩干。
3）整个过程主要是
人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关心洗衣机具体是如何洗衣服的，是如何甩干的。
2.2类的引入
1.引入：
1）C语言只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。
2）例：
// C++兼容C语言，结构体用法可以继续使用
// 同时struct也升级成了类
struct Stack
{
//成员函数
void Init()
{
a = nullptr;
top = capacity = 0;
}
void Push(int x)
{
if (top == capacity)
{
size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
a = (int*)realloc(a, sizeof(int) * newcapacity);
capacity = newcapacity;
}
a[top++] = x;
}
int Top()
{
return a[top - 1];
}
//成员变量
int* a;
int top;
int capacity;
};
int main()
{
//C的玩法
struct Stack st1;
//StackInit(&st1);
//StackPush(&st1, 1);
//StackPush(&st1, 2);
//C++的玩法
Stack st2;
st2.Init();
st2.Push(1);
st2.Push(2);
st2.Push(3);
cout << st2.Top() << endl;
return 0;
}
在上面的结构体中，C++更喜欢用class代替struct（具体差别后面再说）。
2.3类的定义
1.语法：
class ClassName
{
//类体：由成员函数和成员变量组成
//...
}; //一定要注意后面的分号
1）class为定义类的关键字，Classname为类的名字，{}中为类的主体，注意类定义结束后面的分号不能省略。
2）类体中的内容称为类的成员：
1.类中的变量称为类的属性或成员变量
2.类中的函数称为类的方法或成员函数。
2.类的两种定义方式：
1）声明和定义都放在类体中
- 需注意：
1.成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
2.这很好理解，因为如果我们将类定义在.h文件中，然后在多个.cpp文件中引用这个.h文件，要是编译器不将类中的函数当成内联函数处理，就会出现多个函数重定义的情况，符号表重复。
- 代码：
//声明和定义全部放在类体中（先不要管public和private是什么意思，后面会说）
class Person
{
public:
//成员函数（写在类体中，被编译器当成内联函数处理）
//显示
void print()
{
cout << _name << " " << _sex << " " << _age << endl;
}
//初始化
void Init(int age, const char name[], const char sex[])
{
_age = age;
strcpy(_name, name);
strcpy(_sex, sex);
}
private:
//成员变量
int _age;
char _name[10];
char _sex[5];
};
int main()
{
Person human1;
human1.Init(28, "lihua", "man");
human1.print();
return 0;
}
2）类的声明放在.h文件中，成员函数的定义放在.cpp文件中
- 注意：
成员函数名前，需要加上类名，用::限定作用域。
- 代码：
.h文件：
class Person
{
public:
//成员函数
void print();
//初始化
void Init(const char name[], const char sex[], int age);
private:
//成员变量
char _name[10];
char _sex[5];
int _age;
};
.cpp文件
//需要在成员函数名前加上类名
void Person::print()
{
cout << _name << " " << _sex << " " << _age << endl;
}
void Person::Init(const char name[], const char sex[], int age)
{
strcpy(_name, name);
strcpy(_sex, sex);
_age = age;
}
3）一般情况下，推荐使用第二种方式，第二种方式在工作中比较常用，在日常练习中可以选择第一种。
3.成员变量命名规则的建议：
1）看一段代码：
// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
void Init(int year)
{
// 这里的year到底是成员变量，还是函数形参？
year = year;
}
private:
int year;
};
所以，我们一般在类的成员变量前（或后）加上下划线“_”；或者在前面加一个"m"（命名规则不唯一，具体看个人习惯和公司要求）
2）建议的代码风格：
// 所以一般都建议这样
class Date
{
public:
void Init(int year)
{
_year = year;
}
private:
int _year;
};
// 或者这样
class Date
{
public:
void Init(int year)
{
mYear = year;
}
private:
int mYear;
};
2.4类的访问限定符和封装
2.4.1访问限定符
1.C++实现封装的方式：
用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
2.访问限定符说明（访问限定符只作用域外部，对于类的内部，没有public和private的概念，都是可以互相访问的）：
1）public修饰的成员在类外可以直接访问。
2）protected和private修饰的成员在类外不能直接访问（现阶段我们认为protected和private作用类似）。
3）访问权限作用域从该访问限定符出现的位置开始知道下一个访问限定符出现时为止。
4）如果后面没有访问限定符，作用域就到 } 即类结束。
5）class的默认访问权限为private，struct为public（因为C++要兼容C，所以保留struct）。
注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何限定符上的区别。
面试题：C++中struct和class的区别是什么？
1）解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。
2）注意：在继承和模版参数列表位置，struct和class也有区别，后续介绍。
3.例：
class Date
{
public:
//成员函数
void print()
{
cout << _year <<" "<< _month << " " << _day << endl;
}
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
//成员变量（这里只是声明变量，没有定义）
int _day;
int _month;
int _year;
};
//分别把public和private都注释掉，看看程序能否编过
int main()
{
Date a;
a.Init(2004, 8, 22);
a.print();
a._day = 10;
a.print();
return 0;
}
1）如果我们把public和private都注释掉：
会发现类中的内容都无法访问，因为class默认的访问权限是private，外界看不到。
2）只把private注释掉：
类中的成员全都可以访问，因为所有成员的访问权限都是public。
3）将private和public都保留（不注释掉）：
会发现成员变量_day无法正常访问，因为成员变量被private修饰。
4）如果只把public注释掉，结果和全注释掉一样，因为类中的全部内容都是private。
5）再将class换成struct试一下结果（struct里也支持访问权限的设置，这里就不再写了）
2.4.2封装
1.面向对象的三大特性：
- 封装、继承、多态。
2.在类和对象阶段，主要是研究类的封装特性，那么什么是封装呢？
1）封装：
将数据和操作数据的方法进行有机结合，用隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
2）封装本质上是一种管理，让用户方便使用类。如：
1）对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入、显示器、USB接口等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。
2）对于计算机使用者而言，不用关心内部核心部件，比如主板上线路时如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此，计算机在出厂时，会在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
3）在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。
2.5类的作用域
1.类定义了一个新的作用域：
类的所有成员都在类的作用域中（类中的成员可以相互访问，且无视位置）。
无视位置：
1）像在主函数中，我们要想使用一个变量（或函数），这个变量（或函数）就必须在使用位置之前被定义，或声明过，编译器才可以找的到这个变量（或函数）。
2）而在类中，要想在类中使用某个变量（或函数），编译器会直接在这个作用域搜索，只要找的到，就能使用；找不到，就不能使用，没有位置的限制。
在类体外定义成员时，需要使用::作用域限定符指明成员属于哪个类域。
2.代码：
class Person
{
public:
//成员函数
void print();
void Init(const char* name, const char* sex, int age)
{
strcpy(_name, name); //这里成员变量都在下面定义
strcpy(_sex, sex); //且有private修饰，但依然可以使用
_age = age; //体现了类中成员变量的使用无视位置的特性，且成员变量之间不受访问限定符约束
}
private:
//成员变量（声明）
int _age;
char _name[20];
char _sex[10];
};
//在类外定义成员函数，需要指明作用域
void Person::print()
{
cout << _name << " " << _sex << " " << _age << endl;
}
int main()
{
Person human1;
human1.Init("lisi", "man", 25);
human1.print();
//没有在类里声明的函数或变量，是不能定义的，也就是说不能在类外声明变量，C++也就没有提供在类外声明变量的语法
//int Person id;
//报错，这是一个很奇怪的写法，只是意思意思，不能在类外声明变量
return 0;
}
3.复习：
- 关于作用域，有一个比较笼统的概念，一个{}就是一个作用域。
- 任何在一个作用域内定义的变量，出了这个作用域都是会销毁的（无法使用）。
2.6类的实例化
1.什么是类的实例化？
- 用类类型创建对象的过程，称为类的实例化。
2.类实现的细节：
- 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；如：
入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
- 一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类成员变量。
- 错误示范：
int main()
{
Person._age = 100; // 编译失败：error c2059：语法错误：“.”
return 0;
}
Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。
3.做个比方：
- 类实例化出对象就像现实中使用建筑设计图建造出房子，类就是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
2.7类对象模型
2.7.1如何计算类对象的大小？
示例代码：
class A
{
public:
void printA()
{
cout << _a << endl;
}
private:
char _a;
};
问题：
- 类中既有成员，又有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？
2.7.2类对象的存储方式猜测
1.对象中包含类的各个成员：
- 缺陷：
每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。
2.代码只保留一份，在对象中保存存放代码的地址:
3.只保留成员变量，成员函数存放在公共的代码段:
4.问题：
对于上述三种存储方式，那计算机到底是按照哪种方式来存储的？看下面的代码：
//既有成员函数也有成员变量
class A
{
public:
//成员函数
void fun()
{
cout << "A::fun()" << endl;
}
private:
//成员变量
char _ch;
int _number;
};
//只有成员函数
class B
{
public:
//成员函数
void fun();
};
void B::fun()
{
cout << "B::fun()" << endl;
}
//只有成员变量
class C
{
private:
//成员变量
char _ch;
int _number;
};
//空类
class D
{
};
int main()
{
cout << "A:" << sizeof(A) << endl; // 8
cout << "B:" << sizeof(B) << endl; // 1
cout << "C:" << sizeof(C) << endl; // 8
cout << "D:" << sizeof(D) << endl; // 1
return 0;
}
结论：
1） 一个类的大小，实际上就是该类中“成员变量”之和，当然要注意内存对齐。
2） 注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。
5.思考：为什么空类要给1个byte，不给不行吗？
研究下面的代码：
//空类
class A
{
};
int main()
{
//分配1byte，不存储数据，只是占位，表示对象存在过
A aaa1;
A aaa2;
//发现地址是不一样的
cout << &aaa1 << endl;
cout << &aaa2 << endl;
//里面到底放的什么数据，是标准未定义的
//深究没有意义
return 0;
}
如果不给1byte占位，我们无法区分上述两个变量，所以要开一个字节来表示对象存在，以达到区分的目的。
至于这一个byte里到底放什么，是标准未定义的，深究没有意义。
2.7.3复习：结构体内存对齐规则
1.第一个成员在与结构体偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍。
- 对齐数 = 编译器默认对齐数和该成员的较小值
- VS中默认对齐数为8
3.结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是左右最大对齐数（含嵌套结构体的对齐数）的整数倍。
想要详细了解内存对齐，可以去看我的C语言进阶——结构体内存对齐
2.8this指针
2.8.1this指针的引出
1.成员函数在编译器眼里的真实样子：
C++编译器给每个“非静态的成员函数”增加了一个隐藏的指针参数this，让该指针指向当前对象（函数运行时调用该函数的对象），在函数体中，所有“成员变量”的操作，都是通过该指针去访问。所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
图中绿色参数都是编译器自动给的，不需要程序员自己操作。
2.8.2this指针的特性
1.this指针的类型：
类类型* const，即函数成员中，不能给this指针赋值（*this可以改变，this本身不能改变）。
2.只能在函数成员内部使用。
3.this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4.this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。
5.代码演示：
class Date
{
public:
//成员函数
//this在实参和形参的位置不能显示写
//但是在类中可以显示用，this是一个关键字
//void Init(Date* this, int year, int month, int day) //报错，不能显示写
void Init(int year, int month, int day)
{
cout << this << endl;
this->_year = year; //显示用
this->_month = month; //显示用
_day = day;
}
void print()
{
cout << this->_year << " " << _month << " " << _day;
}
private:
//成员变量
int _year;
int _month;
int _day;
};
int main()
{
Date A;
//A.Init(&A, 2023, 7, 27); //不能显示写，传地址也没用
A.Init(2023, 7, 27);
A.print();
return 0;
}
6.面试题：
1）this指针存在哪？
- this是一个形参，一般是存在栈帧里面。
- VS下面一般会用ecx寄存器直接传递。
2）this指针可以为空吗？
- 题1：
// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();
return 0;
}
答案是可以正常运行：
虽然p是一个空指针，并且貌似发生了对空指针的解引用，但上述程序仍然可以正常运行。因为类中的成员函数都放在公共代码段中，类中连函数的地址也不存，所以编译器在执行
p->Print();时，实际上并没有发生空指针的解引用，编译器会直接去类的公共代码段中去寻找函数，进而实现函数功能。
如果将 p->Print(); 换成 *(p).Print();呢？
这两句代码是一个含义，交到编译器手里，他们的汇编代码是一样的。
- 题2：
// 2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class B
{
public:
void PrintA()
{
cout << _a << endl;
}
private:
int _a;
};
int test2()
{
B* p = nullptr;
p->PrintA();
return 0;
}
答案是运行崩溃：
和上一题不同，本题中成员函数使用了成员变量 “_a”，发生了空指针的解引用，接下来我们一步一步分析
首先，执行
p->PrintA();时，编译器会自动将p传给this指针。然后，在成员函数PrintA();中，“_a” 实际为 “this->_a” ，而this是一个空指针，所以发生了空指针的解引用，运行崩溃 。
2.8.3C语言和C++实现Stack的对比
1.C语言的实现：
//1. 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;
}
1）可以看到，在用C语言实现时，Stack相关操作函数有以下共性：
1）每个函数的第一个参数都是Stack*。
2）函数中必须要对第一个参数检测，因为该参数可能会为NULL。
3）函数中都是通过Stack*参数操作栈的。
4）调用时必须传递Stack结构体变量的地址。
2）结构体中只能定义存放数据的结构，操作数据的放法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实际上相对复杂一点，涉及到大量指针操作，稍不注意可能就会出错。
2.C++的实现：
//C++实现
typedef int DataType;
class Stack2
{
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()
{
Stack2 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语言中需要用户自己维护。
940
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
