c++类和对象详解（上篇）
write in front
作者：@ 不进大厂不改名
专栏：@ c++语言
作者简介：大一学生 希望能学习其同学和大佬的经验！
本篇博客简介：c++的类和对象，本系列估计要分为三篇文章，学会了可以了解c++的封装的特点（以及和c++后面的内容进行接轨）。
1.面向对象和面向过程
我们在学习c语言时就经常听到别人说c语言时一门面向过程的语言，而c++和java是基于面向对象的语言。当时听了肯定很疑惑，那么今天我们学了c++后，就发出这个疑问，到底什么是面向过程，什么是面向对象？
这里拿洗衣服这个实例来进行区分：
面向过程
面向过程关注的是过程，分析出求解的过程，分析出求解问题的步骤通过函数调用逐步解决问题。
就像是下面这样：关注的是洗衣服的整个过程
面向对象
面向对象关注的是对象，将一件事情拆分成多个不同对象，靠对象的交互完成。
还是上面洗衣服那个例子：
2.类的引入
C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：
之前在数据结构中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。下面这个例子是用c++写的栈。
#include <iostream>
using namespace std;
typedef int DataType;
struct Stack
{
void Init(size_t capacity)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(const DataType& data)
{
// 扩容
_array[_size] = data;
++_size;
}
DataType Top()
{
return _array[_size - 1];
}
void Destroy()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
DataType* _array;
size_t _capacity;
size_t _size;
};
int main()
{
Stack s;
s.Init(10);
s.Push(1);
s.Push(2);
s.Push(3);
cout << s.Top() << endl;
s.Destroy();
return 0;
}
上面的结构体，在c++中更喜欢用class来代替。
3.类的定义
class hyh 类名
{
类体：由成员函数和成员变量组成
}; 注意后面的分号
其中class为定义类的关键字，hyh为类的名字（可以自由定义），{}中为类的主体，注意类定义结束时后面的分号不能省略。
类体中的内容成为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数。
类的两种定义方式：
1.声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能就当成内联函数处理。
声明和定义全部放在类体中
#include <iostream>
using namespace std;
class People
{
public:
显示基本信息
void ShowInformation()
{
cout << _name << "-" << _sex << "-" << _age << "-" <<_phonenumber<< endl;
}
char* _name; 姓名
char* _sex; 性别
int _age; 年龄
char* _phonenumber; 电话
};
类声明放在.h文件中，成员函数的定义放在.cpp中，注意：成员函数前要加类名::
声明（.h文件中）：
class People
{
public:
//显示基本信息
void ShowInformation();
char* _name;//姓名
char* _sex;//性别
int _age;//年龄
char* _phonenumber;//电话
};
#include <iostream>
using namespace std;
#include "test.h"
void People::ShowInformation() 一定要记得成员函数前要加类名::
{
cout << _name << "-" << _sex << "-" << _age << "-" <<_phonenumber<< endl;
}
一般情况下，更期望采用第二种方式。
成员变量的命名规则：
不好的写法：
class Day
{
public:
void Init(int year)
{
//这里的year到底哪个是成员函数，哪个是函数形参？
year = year;
}
private:
int year;
};
建议写法：
class Day
{
public:
void Init(int year)
{
这样写就能清晰的辨别哪个是成员函数，哪个是形参
_year = year;
}
private:
int _year;
};
其实上其他符号前缀也可以（主要是起区分的作用），主要是看个人习惯和公司要求。
4.类的访问限定符以及封装
访问限定符
c++实现封装的方式：用类将对象的属性与方法结合在一起，让对象更加完美，通过访问权限选择性将其接口提供给外部的用户使用。
访问限定符说明
1.public修饰的成员在类外可以直接被访问
2.protected和private修饰的成员在类外不能被直接访问（此处protected和private是类似的）
3.访问权限作用域从访问限定符出现的位置开始直到下一个访问限定符出现为止
4.如果后面没有访问限定符，作用域就到类结束的地方。
5.class的默认访问权限为private,struct的默认权限是public（因为struct要兼容c）
访问限定符只在编译时有用，当数据映射到内存后，没有访问限定符上的区别
问题：c++中struct和class的区别时什么？
C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。在继承和模板参数列表位置，struct和class也有区别，后面学了再和大家详细介绍哈！
封装
面向对象的三大特性：封装、继承、多态。
在类和对象阶段，主要研究的时封装，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。
对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
封装在c++中的作用：
在c++中实现封装，可以通过将数据以及数据操作的方法进行有机结合，通过访问权限来对隐藏对象内部实现细节，控制那些方法可以在类外部直接被使用。
5.类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用::作用域操作符指明成员属于哪个类域。
#include <iostream>
using namespace std;
class People
{
public:
void PrintPeopleInformation();
char* _name;
char* _sex;
int _age;
};
这里需要指定PrintPeopleInformation是属于People这个类域的
void People::PrintPeopleInformation()
{
cout << _name << " " << _sex << " " << _age << endl;
}
6.类的实例化
用类类型创建类的过程，称为类的实例化
1.类是对对象进行描述，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的空间去存储它，比如：大学入学时填写的学生信息表，表格就可以看成是一个类，来记录学生的具体信息。
2.一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储成员变量
#include <iostream>
using namespace std;
class People
{
public:
void PrintPeopleInformation();
char* _name;
char* _sex;
int _age;
};
void People::PrintPeopleInformation()
{
cout << _name << " " << _sex << " " << _age << endl;
}
int main()
{
People._age = 1; 编译错误,语法错误：“.”;
return 0;
}
People类是没有空间的，只有People实例化出的对象才有具体的年龄。
3.打个比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
7.类对象模型
如何计算类对象的大小
#include <iostream>
using namespace std;
class A
{
public:
void PrintA()
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A a;
return 0;
}
问题:上面的成员变量和函数是怎么存储的呢？
其实上只保存成员函数，成员函数存放在公共的代码段
#include <iostream>
using namespace std;
class A1
{
public:
void f1()
{};
private:
int _a;
};
class A2
{
public :
void f2()
{};
};
class A3
{
};
int main()
{
printf("%d\n", sizeof(A1));
printf("%d\n", sizeof(A2));
printf("%d\n", sizeof(A3));
return 0;
}
你能尝试算出出上面类的大小吗？
答案是：4 1 1
你算对了吗?
是否感到奇怪，空类的大小为什么不是0，而是1，但实际上不是这样子的，我们创造出一个对象就一定会占用空间。结论：一个类的大小，实际上是这个类里面所有成员变量之和，当然它要遵循内存对齐，这个规则和结构体内存对齐一样。下面帮忙会议了一下结构体对齐规则。
结构体内存对齐规则
1 第一个成员在与结构体偏移量为0的地址处。
2 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8
3 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
8.this指针的引出
#include <iostream>
using namespace std;
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++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
this指针的特性
1.this指针的类型：类 类型const，即成员函数中，不能给this指针赋值。
2.this指针本质上时成员函数的形参，当对象调用成员函数时，将对象的地址作为参数传递给this指针，所以对象中不存在this指针。
3.this指针是成员函数的第一个隐含的指针参数，一般情况下由编译器通过ecx寄存器自动传递，不需要用户传递。
this指针存在哪里，this指针可以为空吗？
第一个问题的答案是：大部分情况下存放在栈区（因为this指针是一个形参）
但是在vs中由于this指针要经常使用，所以说编译器就把它优化到寄存器里面了。
对于问题2，我们可以用下面两道题进行很好的回答：
#include <iostream>
using namespace std;
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();
return 0;
}
可以猜一下运行结果是？
#include <iostream>
using namespace std;
class A
{
public:
void PrintA()
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->PrintA();
return 0;
}
那么这个的运行结果是？
第一题：先分析一下这个程序会不会报错,这里做一个简单分析，p是一个空指针this作为一个形参传递进去了，但是函数的调用是不是没有用到this指针，所以这个程序正常运行。
第二题：p是一个空指针this作为一个形参传递进去了，但是这个程序在打印_a时，编译器会处理成this->_a这样空指针是不是被使用了。所以程序最后就崩溃了。
c和c++实现栈的区别
c语言实现
#include <stdio.h>
#include <assert.h>
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++语言实现
#include <iostream>
using namespace std;
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++的优点如下：
c++中通过类将数据以及操作数据的方法进行了完美结合，通过访问权限可以控制哪些方法在类外可以被调用，即封装，在使用时就像是使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递Stack的参数了，编译器之后该参数会自动还原，即c+++中Stack参数是编译器维护的，c语言中是自己维护的。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
