目录
面向过程和面向对象初步认识
C语言与C++之间的区别
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完 成。
本文代码皆没有添加头文件
类的引入
以下的C语言中对结构体的玩法
//C++中对 struct(结构体) 进行了升级
//1、兼容C中 struct 的所有用法
//2、升级成了类
//以下的C语言中对结构体的玩法
typedef int DataType;
struct Stack //在C中只有数据对象
{
DataType* _array;
size_t _capacity;
size_t _size;
};
void StackInit(struct Stack* ps, size_t capacity) //习惯上我们需要在 Init 前加入对应结构体的名字用以区分是在调用哪一个类型的函数
{ //而且我们需要多传一个参数(对应结构体的地址)
ps->_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (nullptr == ps->_array)
{
perror("malloc申请空间失败");
return;
}
ps->_capacity = capacity;
ps->_size = 0;
}
void StackPush(struct Stack* ps, const DataType& data)
{
// 扩容
ps->_array[ps->_size] = data;
++ps->_size;
}
DataType StackTop(struct Stack* ps)
{
return ps->_array[ps->_size - 1];
}
void StackDestroy(struct Stack* ps)
{
if (ps->_array)
{
free(ps->_array);
ps->_array = nullptr;
ps->_capacity = 0;
ps->_size = 0;
}
}
int main()
{
Stack s;
StackInit(&s,10);
StackPush(&s, 1);
StackPush(&s, 2);
StackPush(&s, 3);
cout << StackTop(&s) << endl; //这里直接用C++的方法打印出来了
StackDestroy(&s);
return 0;
}以下的C++语言中对类(上面的结构体)的玩法
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++对其进行了类的封装
typedef struct Queue
{
// ...
}Q;
void QueueInit(Q* pq)
{}
void QueuePush(Q* pq, int x)
{}
int main()
{
// C++中兼容C语言中对结构体的用法
Q q1;//1.用重定义的名字定义一个变量(在C++中叫做对象)
struct Queue q2;//2.直接定义一个变量
QueueInit(&q1);
// 这是C++的用法，这种写法在C语言中是不被允许的
Queue q3;
return 0;
}类的定义
C语言结构体中只能定义变量，在 C++ 中，结构体内不仅可以定义变量，也可以定义函数。 比如：之前在数据结构中，用C 语言方式实现的栈，结构体中只能定义变量 ；现在以 C++ 方式实现， 会发现 struct中也可以定义函数
上面结构体的定义，在C++中更喜欢用class来代替。
把struct换成class
class className
{
// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号class为 定义类的 关键字， ClassName 为类的名字， {} 中为类的主体，注意 类定义结束时后面 分 号不能省略 。类体中内容称为类的成员： 类中的 变量 称为 类的属性 或 成员变量 ; 类中的 函数 称为 类的方法 或者 成员函数 。
类的访问限定符及封装
【访问限定符说明】
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 也有区别，后序再来介绍。
补充：struct里面的成员默认为公开的(public),而class里面的成员默认为私有的(private)
class Stack // 类型
{
public: //访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
void Push(int x)
{
Init(); //这里可以直接访问到该类里面定义的其他函数，既是这个函数在其下方(没有出类域)
//... //这样当有很多这样的成员函数，或者成员对象的时候(也会定义与声明分离)，便于找到
}
void Init(int N = 4)
{
// ...
top = 0;
capacity = 0;
}
private:
int* a; // 声明
int top;
int capacity;
public:
//上面有的话也可以在下面继续使用别的访问限定符，不过习惯上我们只定义一个public与private，还有一个protect(这里并没有使用到)
};
struct Stack_C // 类型
{
int* a; // 声明
int top;
int capacity;
};
int main()
{
//Stack::a = 0; //这是不可以直接访问的，因为只有声明，并没有定义
//Stack_C::a = 0; //在C语言中这种写法同样是不被允许的(原因:非静态成员引用，这里是不正确的)
Stack st;
st.a = 0; //外部是不可以访问类里面的私有成员,但是在类里面就不会受到限制
return 0;
}重新补充一点(防止忘记):缺省值在声明给定，不能在定义中给定(重定义默认参数)
类的两种定义方式：
1. 声明和定义全部放在类体中，需注意：成员函数如果 在类中定义 ，编译器可能会将其当成 内 联函数 处理。2. 类声明放在 .h 文件中，成员函数定义放在 .cpp 文件中，注意： 成员函数名前需要加类名 ::
一般情况下，更期望采用第二种方式。
注意：这里是为了方便演示而使用方式一定义类，后序工作中尽量使用第二种。
成员变量命名规则的建议：
// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
void Init(int year)
{
// 这里的year到底是成员变量，还是函数形参？是不是很不好判断
year = year;
}
private:
int year;
};
// 所以一般都建议这样
class Date
{
public:
void Init(int year)
{
_year = year;
}
private:
int _year;
};
// 或者这样
class Date
{
public:
void Init(int year)
{
mYear = year;
}
private:
int mYear;
};
// 其他方式也可以的，主要看要求。一般都是加个前缀或者后缀标识区分就行【另一道面试题】
面向对象的三大特性：封装、继承、多态。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。封装本质上是一种管理，让用户更方便使用类。
类的作用域
//类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::
//作用域操作符指明成员属于哪个类域。
class Person
{
public:
void PrintPersonInfo();
private:
char _name[20];
char _gender[3];
int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
cout << _name << " " << _gender << " " << _age << endl;
}
int main()
{
return 0;
}类域的使用注意事项
//类域相当于建筑房的图纸，图纸并不能被居住(访问)，只有通过图纸建立的房子才可以居住(访问)
class Person
{
public:
void PrintPersonInfo()
{ }
//private: //即使把这里改为共用的，也不可以直接访问里面的成员变量,因为里面不是实体，在没有创立对象的时候，里面都是声明
char _name[20];
char _gender[3];
int _age;
};
int main()
{
//Person::_age = 1; //成员变量不可以直接访问，因为不存在
//Person::PrintPersonInfo(); // this指针,与上面的原因不同
//除非是静态的，这一点后面再解释
return 0;
}类对象模型
如何计算类对象的大小
类对象的存储方式猜测
注意：成员函数编译好后，那些指令是存放在常量区(代码段)的
问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？
这里后两个类的大小都是1，是为了占位
在C++中空类会占一个字节，这是为了让对象的实例能够相互区别。具体来说，空类同样可以被实例化，并且每个实例在内存中都有独一无二的地址，因此，编译器会给空类隐含加上一个字节，这样空类实例化之后就会拥有独一无二的内存地址。如果没有这一个字节的占位，那么空类就无所谓实例化了，因为实例化的过程就是在内存中分配一块地址。
结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。
结构体内存对齐规则
1. 第一个成员在与结构体偏移量为0的地址处。2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的对齐数为83. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
【一些关于内存对齐的面试题】
1. 结构体怎么对齐？ 为什么要进行内存对齐？2. 如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景
关于类域的内存的对齐，C++与C语言的数据结构是一样的，下文转详解
this指针
通过下面的例子，可以知道this指针是存在的
//this 指针
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
cout << this << endl;
//cout << this->_year << "-" << this->_month << "-" << this->_day << endl; 可以使用上 this，但是我们通常并不这样写，因为编译器会帮我们实现
} //this 在后面才会有它的用武之地
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();
cout << endl;
cout << &d1 << endl;
cout << &d2 << endl;
return 0;
}
回到上面的问题
this指针的特性
1. this指针的类型：类类型* const ，即成员函数中，不能给 this 指针赋值。2. 只能在 “ 成员函数 ” 的内部使用3. this指针本质上是“成员函数”的形参 ，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以 对象中不存储this指针 。4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
对1的补充
【this指针的面试题】
1. this
指针存在哪里？
解析：容易认为是在常量区或者对象里面。对象：当用 sizeof 的时候就可以知道，this是不放在对象里面的常量区： 成员函数编译好后，那些指令是存放在常量区(在操作系统里面叫代码段)，这里容易被误解正确是在 栈帧 里面的：因为 this 与其他的一样都是参数，而且是形式参数，而形参是放在函数调用时候建立的栈帧里面的，跟着局部变量一起走
还有注意一点的是在
VS 里面，对
this 进行了优化，使用
ecx寄存器 进行传递
2. this
指针可以为空吗？
小心：还有一点需要注意的是空指针的解引用，编译器是检查不出来的，它是运行错误
总结：
可以看到，在用
C
语言实现时，
Stack
相关操作函数有以下共性：
1.每个函数的第一个参数都是Stack*2.函数中必须要对第一个参数检测，因为该参数可能会为NULL3.函数中都是通过Stack*参数操作栈的4.调用时必须传递Stack结构体变量的地址
结构体
中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据
的方式是分离开的
，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出
错。
C++
中通过类可以将
数据
以及
操作数据
的方法进行完美结合，通过访问权限可以控制那些方法在
类外可以被调用，即封装
，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递Stack*
的参数了，编译器编译之后该参数会自动还原，即
C++
中
Stack *
参数是编译器维护的，
C
语言中需用用户自己维护
。
结束语
若教眼底无离恨，不信人间有白头。
辛弃疾——《鹧鸪天·晚日寒鸦一片愁》