【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++中更喜欢用class来代替。

通过上面的代码，我们发现C++中类的作用是非常显著的！比C语言简便许多！

可以直接将函数定义在类的内部，如果一个工程中定义多个数据结构，我们只需要将类进行实例化，不需要担心不同数据结构的函数回命名冲突。

三、类的定义

cpp 复制代码

class className
{
// 类体：由成员函数和成员变量组成
};  // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：

类中的变量称为类的属性或成员变量;

类中的函数称为类的方法或者成员函数。

类的成员函数两种定义方式：

1. 声明和定义全部放在类体中

需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

为什么是可能将其看成内联函数呢？

因为编译器有自己的一套保护系统，不信任程序员，前文讲过内联函数如果代码量过于大（一般超过10行就算大），就自动不认为他是一个内联函数，就算定义在类里面也不行。

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中

注意：成员函数名前需要加类名::

标准正确定义的方法：

长的函数声明和定义分离；短小的函数可以直接在类里面定义

成员变量命名规则的建议：

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;
};
// 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

四、类的访问限定符

访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用

【访问限定符说明】

public修饰的成员在类外可以直接被访问
protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
如果后面没有访问限定符，作用域就到 } 即类结束。
class的默认访问权限为private，struct为public(因为struct要兼容C)

问题：C++中struct和class的区别是什么？

解答：

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

五、类的实例化

用类类型创建对象的过程，称为类的实例化（类和对象的关系）

一个类可以实例化出多个对象，实例化出的对象才占用实际的物理空间，存储类成员变量

Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。

cpp 复制代码

int main()
{
 Person._age = 100;   // 编译失败：error C2059: 语法错误:"."
 return 0;
}

类的实例化正确使用方法：

六、如何计算类对象的大小

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

如果对象中包含类的各个成员？

每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

所以我们采取下面的存储方式

结论：

一个类的大小，实际就是该类中"成员变量"之和，当然要注意内存对齐

注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

计算类的大小时，类的成员函数不包括在内，为何？

因为不同的对象使用的都是同一个函数（比如初始化函数等），但不同的对象使用的都是不同的成员变量。多次调用相同函数而浪费了空间，因此我们可以把函数存储在公共区域，不用计入类的大小。

七、this指针

cpp 复制代码

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个参数，本来有一个参数，就会有2个参数，那个多出来的参数就是this传的参数

面试题：

1、this指针存在哪里，是存在对象里面的吗

首先明确this指针不可能存在对象里面，我们上文讲过计算对象的大小时，是没有计算this指针大小的，所以反向思维this指针是不存在对象里。

this指针实际上是一个形参，是存放在栈帧里面的，VS编译器下，是存放在ecx寄存器里面。

2、比较下面两种代码的区别

注意对空指针解引用是运行错误，编译时不会报错。

上面代码执行结果为什么是正常运行？

我们来分析一下。

首先p是一个指针，并且是空指针，注意当指针定义的对象时，就需要用**->**来访问成员变量。

那p是空指针了怎么再访问Print函数呢？

我们不要忘了成员函数的地址不在对象中，只有成员变量才存放在对象中！

所以p里面根本就没有函数，也就不存在指针解引用了。

这里的p作用表示在编译时检查Print是不是在类里面。

再对比看看下面的代码：

因为this指针就是空指针，而解引用空指针去访问成员变量肯定是报错的！

八、static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。

静态成员变量一定要在类外进行初始化！类里面声明，类外面定义

原因：

类里面初始化的缺省值，本质上是给初始化列表的，但是静态成员变量不要走初始化列表，因为初始化列表要定义一个对象里的成员。但是静态成员变量不是属于某个对象的，是属于整个类的

面试题：实现一个类，计算程序中创建出了多少个类对象。

cpp 复制代码

class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }
private:
static int _scount;
};

int A::_scount = 0;//静态成员变量需要在类外初始化

void TestA()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}