类和对象

目录

前言：

1.类的引入

2.类的定义

2.1类的两种定义方式

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

3.1封装

3.2访问限定符

4.类的作用域

5.类的实例化

6.this指针

---

前言：

面向过程和面向对象

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

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

例如把大象放进冰箱

1.类的引入

c语言中的结构体只能定义变量，在c++中，结构体可以定义变量，也可以定义函数。如c语言实现的栈，结构体中只能定义变量，c++实现的话，struct中可以定义函数

结构体中只能定义变量，并且声明栈类型的变量时，必须写全struct Stack。

typedef int DataType;
struct Stack
{
	DataType* _array;
	size_t _capacity;
	size_t _size;
};

struct Stack s;//声明一个结构体变量

C++中，struct结构体升级成了类，它里面不仅可定义变量，还可以定义函数，并且声明栈类型变量的时候，可以不加struct。声明的变量可以通过.去调用类里面的函数。

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;
};
Stack s;//声明一个栈类型对象
s.Init();//调用类里面的函数
s.Push(10);
s.Push(20);
s.Push(30);
s.Push(40);
int ret = s.Top();
s.Destroy();

2.类的定义

class name
{
    类体：由成员函数和成员变量组成
};    //注这里有分号哦

class 关键字
name 类名
{} 放类的主体
类体中的内容：成员变量
类中的变量：类的属性或成员变量
     函数：类的方法或成员函数

C++中可以用struct来定义一个类，但更多是用class关键字来定义类。

2.1类的两种定义方式

全部放在类体中

//定义一个人的类
class Person
{
	//成员函数------显式基本信息
	void show()
	{
		cout << _name << "-" << _sex << "-" << _age << "-" << endl;
	}
	//成员变量
	char* _name;//姓名
	char* _sex;//性别
	int _age;//年龄
};

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

Person.h文件
//定义一个人的类
class Person
{
	//成员函数------显式基本信息
	void show();
	//成员变量
	char* _name;//姓名
	char* _sex;//性别
	int _age;//年龄
};

Person.cpp文件
#include "Person.h"

void Person::showInfo()
{
	cout << _name << "-" << _sex << "-" << _age << "-" << endl;
}

注 ：成员函数名前需要加类名::，告诉编译器这个函数属于哪个类域。

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

3.1封装

面向对象的三大特性：封装，继承，多态

封装：把数据和操作数据的方法进行有机的结合，隐藏对象的属性和实现细节，仅对外公开接口来和对现象进行交互。（把功能包起来，只留接口）

（冰箱里面怎么制冷、怎么转动、电线怎么走，你不用知道。你只需要用：开门，关门）

3.2访问限定符

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

C++提供了三种限制权限的访问限定符 ：public、protected、private。

注

访问限定符可以修饰类中的成员变量、成员函数、内部类、重命名类型 。友元函数的声明不受访问限定符的限制。（friend）
public 修饰的成员，在类外面可以直接被访问（通过对象.访问）。
protected 和private 修饰的成员在类外面不能直接被访问，目前我们认为它们两个一样，只有在继承的时候，这俩才有区别。
访问权限的作用域 ：从该访问限定符出现的位置开始，直到下一个访问限定符出现为止。如果后面没有访问限定符，作用域就到}即类结束。

class的默认访问权限是private，struct为了兼容C语言，默认访问权限是public。

访问限定符只在编译时有用，当数据映射到内存后，没任何访问限定符上的区别。

4.类的作用域

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

//Person.h文件
//定义一个人的类
class Person
{
	//成员函数------显式基本信息
	void show();
	//成员变量
	char* _name;//姓名
	char* _sex;//性别
	int _age;//年龄
};

//Person.cpp文件
#include "Person.h"

void Person::show()
{
	cout << _name << "-" << _sex << "-" << _age << "-" << endl;
}

如上面的成员函数show ，对于函数体中出现的变量**_name，_sex,_age**，编译器会先在当前函数的局部域中搜索，如果没有找到，接下来会到对应的类域里面去搜索，当类域里面也没有的时候，最后回到全局区搜索，如果全局也没有，编译就会报错。

**注意：**所有的域都会影响访问，但是只有全局域和局部域会影响生命周期，而类域和命名空间域不会影响声明周期。

类域主要影响访问，局部域可能影响生命周期。

生命周期与存储的位置有关系，存储在栈，堆，静态区，常量区的生命周期各不相同。

作用域跟编译器的搜索规则有关系：先局部后全局。

5.类的实例化

实例化概念
1.⽤类类型在物理内存中创建对象的过程，称为类实例化出对象。
（例如 ）

2.类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只 是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。

例如

上面代码构建了一个人的基本信息

#include<iostream>
int main()
{
	Person p1;//用类实例化一个对象p1
	p1._name = "晴天";
	p1._sex = "男";
	p1._age = 22;
	//Person._name = "jay";//这是错的
	return 0;
}

6.this指针

class Date
{
public:
//this 是作为一个关键字存在
//this 指针 本质上是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给 this 形参。所以对象中不存储 this 指针。
//this 指针是成员函数第一个隐含的指针形参，一般情况由编译器通过 ecx 寄存器自动传递，不需要用户传递。
    // 实参和形参位置不能显示传递和接收this指针
	// 但是可以在成员函数内部使用this指针
	
	//void Init(Date* const this, int year, int month, int day)
	void Init(int year, int month, int day)
	{
		//this = nullptr;   error
		cout << this << endl;//打印this指针的地址
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	
	//void Print(Date* const this)
	void Print()
	{
		cout << this << endl;
		cout << this->_year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;     // 年   -> 声明
	int _month;    // 月
	int _day;      // 日
};

int main()
{
	Date d1;
	d1.Init(2026, 3, 19);//d1.Init(&d1, 2026, 3, 19);
	d2.Print();//d2.Print(&d2);

	Date d2;
	d2.Init(2026, 3, 19);//d2.Init(&d2,2026, 3, 19);
	d1.Print();//d1.Print(&d1);

    
	return 0;
}

虽然d1和d2调用的是同一个函数 ，但是调用时传递的参数不同 ，所以最终谁调用，打印的就是谁的结果。我们可以在成员函数中去显式使用this，但是不能在形参或者实参中自己去显式传递this

1.注意

1.this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。只能在"成员函数"的内部使用

2.this指针本质上是"成员函数"的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

关于this指针能为空吗？