目录

 一、面向过程和面向对象初步认识

二、类的引入

三、类的定义

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

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

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

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

四、类的访问限定符

【访问限定符说明】

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

五、类的实例化

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

结论：

七、this指针

面试题：

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

八、static成员

静态成员和静态成员函数的特性

九、对于隐式类型转换的那些事儿

第一类是内置类型中的隐式类型转换，主要就是整形和浮点型之间的转换。

第二类就是内置类型隐式类型转换为自定义类型

 一、面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

C++是基于面向对象的，关注的是对象，将一件事拆分成不同的对象，靠对象之间的交互完成。

二、类的引入

C++中的类相比于C语言的结构体有两点升级。

1、类名就是类型，Stack就是类型，不需要加struct（在C语言中类型还要加上struct）

2、 C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

<code>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语言简便许多！

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

三、类的定义

class className

{

// 类体：由成员函数和成员变量组成

};  // 一定要注意后面的分号

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

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

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

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

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

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

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

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

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

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

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

标准正确定义的方法：

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

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

<code>// 我们看看这个函数，是不是很僵硬？

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类实例化出的对象才有具体的年龄。

<code>int main()

{

 Person._age = 100;   // 编译失败：error C2059: 语法错误:“.”

 return 0;

}

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

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

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

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

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

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

结论：

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

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

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

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

七、this指针

<code>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修饰的成员函数，称之为静态成员函数。

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

原因：

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

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

<code>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;

}

静态成员和静态成员函数的特性

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

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

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

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

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

总结一下：

静态成员函数和静态成员变量，本质就是受限制的全局变量和全局函数，专属这个类，受类域和访问限定符的限制。

问题：

1、静态成员函数能调用非静态成员函数吗？

答：不可以，因为静态成员函数没有this指针，同样也不能访问非静态成员变量

2、非静态成员函数能调用静态成员函数吗？

答：可以

九、对于隐式类型转换的那些事儿

首先分为两大类：

第一类是内置类型中的隐式类型转换，主要就是整形和浮点型之间的转换。

注意这里引用需要加上const，但赋值不需要加。因为隐式类型转换中间会产生临时变量，而临时变量具有常性！这里的引用是将临时变量引用给了r，具有常性，所以要加上const；而赋值是将临时变量直接赋值给d，不需要加上const！

第二类就是内置类型隐式类型转换为自定义类型

注意这里的   A aa3 = 3   就是将内置类型隐式转换为了自定义类型，原理是自定义类型中包含了int单参数构造函数（支持传一个参数或者多参数带缺省也可以）的支持，如果不想让转换发生，构造函数加explicit关键字。

注意这里的引用需要加上const原理与上面一样，因为隐式类型转换会生成临时变量，而临时变量会具有常性。

如果是多参数，可以选择用大括号  { }  进行表示！