C++类和对象上

1.面向过程和面想对象的初步认识

C语言是面向过程的，关注的是过程，所谓过程就是解决问题的步骤，通过函数调用逐步来解决问题。（比如：做饭，需要买菜、洗菜、切菜和炒菜这几个步骤）。

---

C++是基于面向对象的，关注的是对象，将一件事儿拆分成不同的对象之间的交互完成。C++认为万事万物都皆为对象，对象上有其属性，行为。（比如：人类，属性：身高、体重、年龄…；行为：走、跑和跳）。

• 关键词解释：
  成员变量（属性）：在类内声明的变量，属于对象。
  成员函数（行为）：在类内声明定义的函数，不属于对象，存放在代码段当中。（代码段：存放函数体的二进制代码）。

2.类的引入

我们首先先看两段代码分别是由C和C++实现的：

//c语言
struct Node
{
	int val;
	struct Node* next;//C语言将struct Node 作为数据类型
};

//C++
struct Node
{
	int val;
	Node* next;//而C++ 则将Node作为类名
};

由此可知C++对于类的定义是源自于C语言的结构体的定义，在C++中将C语言由struct定义的结构体名称成为类。

---

在C语言中，结构体内只能声明和定义结构体变量，而无法声明或者定义函数。而在C++中在类的里面既可以声明和定义成员变量还可以声明和定义成员函数。

//c++
struct Stack
{
public:
	//成员函数
	void Init(int n = 4)//定义缺省值参数
	{
		int* tmp = (int*)malloc(sizeof(int) * n);
		if (tmp == NULL)
		{
			perror("malloc fail");
			exit(-1);
		}
		a = tmp;
		top = 0;
		capacity = n;
	}
	//成员变量
private:
	int* a;
	int top;
	int capacity;
};
int main()
{
	Stack st;
	st.Init();
	return 0;
}

//c
struct Stack 
{
	int top;
	int capacity;
	int* a;
};
void StackInit(Stack* st,int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	st->a = tmp;
	st->top = 0;
	st->capacity = n;
}
int main()
{

	Stack st;
	StackInit(&st,4);
	return 0;
}

将结构体升级成了类有两大意义：

1. C++中结构体变量（类名）可以直接作为类型进行使用
2. 在类里面，出了可以声明变量之外，还可以声明和定义函数。

3.类的定义

• 语法：class/struct 类名 {访问权限（下面介绍）: 属性（成员变量）/行为（成员函数）};//一定注意不要忘记有分号 实际上还是定义变量类型

3.1类的两种定义方式

• 在成员函数在类内是实现（声明和定义在一起）
  需要注意的是：成员函数如果在类内中定义，编译器可能将其当成内敛函数处理。

struct Stack
{
public:
	//成员函数
	void Init(int n = 4)//定义缺省值参数
	{
		int* tmp = (int*)malloc(sizeof(int) * n);
		if (tmp == NULL)
		{
			perror("malloc fail");
			exit(-1);
		}
		a = tmp;
		top = 0;
		capacity = n;
	}
	//成员变量
private:
	int* a;
	int top;
	int capacity;
};
int main()
{
	Stack st;
	st.Init();
	return 0;
}

• 类内函数声明和定义不在分开
  类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

#pragma once
#include"Stack.h"
//.c 文件
void Stack::Init(int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	a = tmp;
	top = 0;
	capacity = n;
}

#pragma once
#include<iostream>
using namespace std;

struct Stack
{
public:
	//成员函数  .h文件 成员函数的声明
	void Init(int n = 4);//定义缺省值参数
	//成员变量
private:
	int* a;
	int top;
	int capacity;
};

一般情况下，推荐使用第二种方式。

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

在给成员函数的命名时，我们一定要谨慎如下情况：

class Date
{
public:
	void Init(int year,int month,int day)
	{
		year = year;
		month = month;
		day = day;
	}
private:
	int month;
	int year;
	int day;
};
int main()
{
	Date d1;
	d1.Init(2023, 7, 19);
	return 0;
}

成员函数名称和成员函数形参相同了，编译是能通过的，但是实际上初始化的值赋值给了形参。（局部优先）

为了避免以上情况我们可以在声明成员变量的时候将变量名定义特殊一些以免和形参相同。

4.类的访问限定符及封装

4.1访问限定符

• C++实现封装的方式：用类将对象的属性和行为结合在一起，让对象更加完善，通过访问权限选择性的将其接口提供给外部用户使用。
• 访问限定符:public(公有)、protect(保护)、private(私有)。
• 访问限定符说明

1. public修饰的成员在类外可以直接被访问（类内类外都可以访问）。
2. protected和private修饰的成员在类外不能直接被访问(类内访问，类外不能访问)。
3. 访问权限作用域从该访问限定符出现的位置开始知道下一个访问限定符出现时为止（若没有下一个访问限定符则遇到}为止也就是说遇到类结束为止）。
4. class的默认访问权限为private,struct为public(因为struct要兼容c)。

-**NOTE：**访问限定符旨在编译时有用，当数据映射道内存之后，没有任何访问限定符上的区别。

-面试题 C++中struct和class的区别是什么？
答案：C++是需要兼容C的，所以C++中的struct是可以当成结构体来使用的，另外C++中struct还可以用来定义类和class作用是一样的。C++中class定义类默认访问权限符是private，而struct定义类默认访问权限符是public（为了要兼容C）。

4.2 封装

• 面试题： 面向对象的三大特性是什么？
  答案：封装、继承和多态。

4.2.1 封装的定义

将数据和操作数据的方法作为一个整体，对对象的属性和行为加以权限控制来隐藏对象的属性和实现细节，仅仅对外公开接口来和对象进行交互，表现生活中的事物。

4.2.1封装的本质

封装的本质是一种管理，让用户更加方便的使用类。例如：电脑主机是由CPU、主板、显卡、散热器、电源等等组成，它们之间的相互联系和内部的实现我们是看不到的封装好的，我们只需要按开机键即可。

5.类的作用域

• 域作用操作符 ::，顾名思义就是解析后面符号所属的作用域。主要有以下几种使用场景：

1. 在类外定义函数和静态变量。
2. 通过类名访问静态变量和函数。
3. 引入命名空间。
4. 访问全局变量。

• 类的作用域
  类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员的时候，需要使用::作用域操作符来指明成员属于哪个类域。

class Date
{
public:
	void Init(int year, int month, int day);
private:
	int _month;
	int _year;
	int _day;
};
void Date::Init(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}
int main()
{
	Date d1;
	d1.Init(2023, 7, 19);
	return 0;
}

---

6.类的实例化

• 实例化
  类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，成员有哪些行为。对于这些并没有实际分配空间来存储它们。而实例化，则需要开辟空间去存储它里面的成员变量。记住，成员函数不在对象中，因此不需要为成员函数创建空间。我们可以把类当做成房子图纸，把类的实例化当作成一栋栋真正的房子。成员变量是房子里面的家具，而成员函数是小区里面的广场。
  一个类可以实例化多个对象。
  下面是代码示例：

class Person 
{

	void doWork()
	{
		cout << "刷牙" << endl;
	}
private:
	int _age;
	string _name;
	int _height;
};

int main()
{
	Person p1;//这个就是实例化的过程 实例化出一个人
	Person p2;
	return 0;
}

7.类的对象大小的计算

我们先看以下代码并且思考会输出多少？

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A a;
	cout << sizeof(a) << endl;
	return 0;
}

答案是　输出4；
原因是对象内只存储成员变量，而成员函数存放在代码段中，那么为什么成员函数不在对象中呢？答案是因为如果放在对象中每次创建一个实例化对象都要对成员函数创建空间的化会占用很大空间，因此需要将成员函数存放在公共区域中。

那接下来的代码，分别输出多少呢？

class A1 {
public:
	void f1() {}
private:
	int _a;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};
int main()
{
	A1 a1;
	A2 a2;
	A3 a3;
	cout << sizeof(a1) << endl;
	cout << sizeof(a2) << endl;
	cout << sizeof(a3) << endl;
	return 0;
}

答案是：4　1　1
我们分析下后面两个为什么是１而不是0呢？
首先，类的实例化就是开辟一个空间。如果大小为0就以为着没有空间分配给对象也就没有这两个实例化对象了。那么1比特的作用是什么呢？１比特不存放有效数据，是用来标识对象被实例化出来了。占位用的。

8.类成员函数的this指针

8.1 this指针的引出

我们先定义一个日期类：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2;
	d1.Init(2023, 2, 22);
	d2.Init(2023, 6, 22);
	return 0;
}

分别用类定义了两个实例化对象，它们分别取调用Init函数，而函数体中没有关于不同对象的区分，那它们调用的时候函数是怎么区分是设置ｄ１的还是ｄ２的呢？
－**this指针：**C++编译器给每个”非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象（函数运行时调用该函数的对象），在函数体重所有”成员变量“的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户是不需要自己来传递的，编译器自动完成。

8.2 this指针的特性

1. this指针的类型：类型为*const，即成员函数中，不能个this指针赋值。
2. 只能在”成员函数中“的内部使用。
3. this指针本质上是”成员函数“的形参（存放在栈中），当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this一般情况（vs中）通过ecx寄存器自动传递，必须要用户传递。

8.3面试题

1. this指针存放在哪儿里？
   答案：存放在栈区，以为this指针作为成员函数的形参，形参存放在栈区中。
2. this指针可以为空吗？
   先说答案是可以为空的但是一定要注意不能对指向空的this指针做解引用操作。
   举一个例子：

class A
{
public:
	void func()
	{

	}
	void Init(int val)
	{
		_val = val;
	}
	int _val;
};
int main()
{
	A* a = nullptr;//对象指向空
	//1.下面成序编译运行结果是？
	//编译报错   运行崩溃   运行正常
	a->func(); //答案 正常原型 
	a->Init(1); //答案 运行崩溃
	a->_val = 2022;//运行崩溃
	(*a).func();//答案 运行正常
	A::Init(1);//编译报错，需要传递this指针
	return 0;
}

总结this指针可以为空，但是一定要注意的是不能对this指针进行解引用操作。

9.C语言和C++在实现栈对比

1. C++数据和方法都封装到类中，而C语言数据和方法是分离的。调用过程相比较C++繁琐，而且还容易出错。
2. C++控制访问方式，更安全。而C语言数据访问权限是自由的，不受限制的。