c++初阶-------类和对象

作者前言

✨✨✨✨✨✨
​ 作者介绍：

作者id：老秦包你会，
简单介绍：
喜欢学习C语言、C++和python等编程语言，是一位爱分享的博主，有兴趣的小可爱可以来互讨
个人主页::小小页面
gitee页面:秦大大

一个爱分享的小博主 欢迎小可爱们前来借鉴

---

面向对象和面向对象的认识

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

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

类的引入

我们知道C语言的struct的结构体只能定义变量，不能定义函数，所以我们只能在结构体外定义，但在c++中不仅继承了C语言的struct的所有用法，还补充了C语言结构体不能定义函数的用法

#include
#include
using std::cout;
using std::endl;
using std::cin;
struct SList
{
	int* a;
	int top;
	int capacity;
	//插入
	void Push(int x)
	{
		if (top == capacity)
		{
			//扩容
			int t = capacity > 0 ? 2 * capacity : 4;
			int* tmp = (int*)realloc(a, sizeof(int) * t);
			if (tmp == NULL)
			{
				perror("ralloc");
				return;
			}
			capacity = t;
			a = tmp;
		}
		a[top] = x;
		top++;
	}
	//初始化
	void Init()
	{
		a = NULL;
		top = 0;//栈底元素下一个
		capacity = 0;
	}
	//删除
	void Pop()
	{
		top--;
	}
};
int main()
{
	SList stack;
	stack.Init();
	stack.Push(4);
	stack.Push(3);
	stack.Push(2);
	stack.Push(1);
	stack.Pop();
	return 0;
}

类的定义

相比于struct定义类，c++更喜欢使用class来定义

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

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分
号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

访问限定符

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

访问限定符有三种 public、protected private

#include
#include
using std::cout;
using std::endl;
using std::cin;
class SList
{
protected:
	int* a;
	int top;
	int capacity;
public:
	//插入
	void Push(int x)
	{
		if (top == capacity)
		{
			//扩容
			int t = capacity > 0 ? 2 * capacity : 4;
			int* tmp = (int*)realloc(a, sizeof(int) * t);
			if (tmp == NULL)
			{
				perror("ralloc");
				return;
			}
			capacity = t;
			a = tmp;
		}
		a[top] = x;
		top++;
	}
	//初始化
	void Init()
	{
		a = NULL;
		top = 0;//栈底元素下一个
		capacity = 0;
	}
	//删除
	void Pop()
	{
		top--;
	}
};
int main()
{
	SList stack;
	stack.Init();
	stack.Push(4);
	stack.Push(3);
	stack.Push(2);
	stack.Push(1);
	stack.Pop();



	return 0;
}

【访问限定符说明】

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

类的方法声明和定义分离

在类中，函数的定义有两种，
一种是在类的内部进行定义，编译器可能会将其当成内联函数处理。相当于函数被inline修饰了，至于会不会被展开，由编译器决定的>。
上面的代码就是在类的内部定义的

另一种就是在头文件里面声明，然后在其他cpp文件定义
头文件

#include
#include
using std::cout;
using std::endl;
using std::cin;
class SList
{
protected:
	int* a;
	int top;
	int capacity;
public:
	void Push(int x);
	void Init();
	//删除
	void Pop()
	{
		top--;
	}
};

cpp文件

#include"day2_1.h"
//插入
void SList::Push(int x)
{
	if (SList::top == capacity)
	{
		//扩容
		int t = capacity > 0 ? 2 * capacity : 4;
		int* tmp = (int*)realloc(a, sizeof(int) * t);
		if (tmp == NULL)
		{
			perror("ralloc");
			return;
		}
		capacity = t;
		a = tmp;
	}
	a[top] = x;
	top++;
}
//初始化
void SList::Init()
{
	a = nullptr;
	top = 0;//栈底元素下一个
	capacity = 0;
}
int main()
{
	SList stack;
	stack.Init();
	stack.Push(4);
	stack.Push(3);
	stack.Push(2);
	stack.Push(1);
	stack.Pop();
	return 0;
}

函数里面的变量会先在当前的{}里面找,找不到就会去对应的类里面找

我们在看到很多人写的c++代码里面的成员很多都会加 -

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

封装

C++中的封装是面向对象编程的特性之一，它允许将数据和操作封装在类的内部，对外部隐藏实现细节。通过使用访问修饰符（public、private、protected），可以控制类成员的访问权限，实现数据的安全性和可控性。

类的作用域

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

类的实例化

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 data;
	data.Init(2024, 1, 1);
}

当我们使用这个类来创建一个变量,就是实例化对象

一个类可以实例化很多个对象

类的大小

#include
#include
using std::cout;
using std::endl;
using std::cin;
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 data;
	data.Init(2024, 1, 1);
	Date data1;
	data1.Init(2024, 1, 1);
	Date data2;
	data2.Init(2024, 1, 1);
	cout << sizeof(Date);


}

可以发现类的大小是12,所以可以说明,类的方法的大小在类中不计算(内存对齐)

在反汇编中我们可以看到,不同对象的类的方法的地址是一样的,而不同对象的成员是不一样的,

类的存储方式的猜测

我们假设一下:
1.每创建一个对象,都会保存对应成员的所有代码（我们可以想象就是为类函数和成员变量都开辟空间）

这样给内存造成了很大的浪费,
2. 每创建一个对象,都会保存类的成员变量的空间和类的方法的地址（简单的理解就是开辟成员变量的空间和存储对应类的方法的地址）

3. 类只保存成员变量的大小，成员函数存放在公共区域

#include
#include
using std::cout;
using std::endl;
using std::cin;
class Ta
{
public:
	void Fun()
	{

	}
private:
	int _a;
};
int main()
{
	Ta var;
	cout << sizeof(var);
	return 0;
}

这种情况可以说明，类的储存的情况是按照第三种来的，多个对象调用同名类成员函数是同一个函数

类的大小的特殊情况

#include
#include
using std::cout;
using std::endl;
using std::cin;
class Ta
{
};
int main()
{
	Ta var;
	cout << sizeof(var);
	return 0;
}

#include
#include
using std::cout;
using std::endl;
using std::cin;
class Ta
{
public:
	void Fun()
	{

	}
};
int main()
{
	Ta var;
	cout << sizeof(var);
	return 0;
}

这里涉及的知识有点多，后面讲解
准确的说，成员变量存在对象里面，其他的成员不是

this 指针

上面可能就会有疑问，不同的对象的成员变量不同，但是成员函数是相同的，那这个成员函数怎么区分这些成员变量是来自哪个对象的呢

#include
#include
using std::cout;
using std::endl;
using std::cin;
class Ta
{
public:
	void Fun()
	{
		cout << _a << endl;
	}
	void Fun(Ta * _this)
	{
		cout << _this->_a << endl;
	}
public:
	int _a;
};
int main()
{
	Ta var;
	cout << sizeof(var)<<endl;
	var._a = 10;
	var.Fun();
	var.Fun(&var);
	return 0;
}

再结合我们之前的C语言写一个栈的时候，要传一个结构体的地址，而在c++可以不用，是因为c++编译器做了很多的步骤，就是解决了传结构体的地址的这个步骤

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏
的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”
的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编
译器自动完成

this的介绍

上面我们知道，类的成员函数都有一个隐藏的this指针
头文件：

include<iostream>
using std::cout;
using std::endl;
using std::cin;

class Data
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
		cout <<this-> _year << "-" << this->_month << "-" << this->_day << endl;
	}
	void priyear();
	void Init(int year, int month, int day);


private:
	int _year;
	int _month;
	int _day;

};

cpp文件

void Data::priyear()
{
	cout << this->_year << endl;
}
void Data::Init(int year, int month, int day)
{
	this->_year = year;
	this->_month = month;
	this->_day = day;
}
int main()
{
	Data time1;
	Data time2;
	time1.Init(2024,1,1);
	time2.Init(2024, 1, 2);
	time1.Print();
	time2.Print();
	return 0;
}

一般我们不会写出this这个指针，新手可以写出来熟悉一下
注意一下： this指针不是存在对象里面的，（前面我们计算类的大小，只包括成员变量，不包括this指针，所以可以说 this指针不是存在对象里面的）

准确的说this就是一个形参，形参是存放在栈帧上面的，所以this存在于栈帧

小练习：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{ 
public:
    void PrintA() 
   {
        cout<<"print()"<<endl;
   }
private:
 int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

这道题正常运行，前面我们学习了类的大小，知道类的成员函数是存储在公共区域的，并且函数地址也不在类中,调用类的成员函数,是在链接的符号表进行寻找的,然后找到对应的地址去进行运行,
写这个"p->PrintA();"是为了表明这个函数出自A这个结构体,而实际不存在类中

在字符表找到地址就是红框里面的

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{ 
public:
    void PrintA() 
   {
        cout<<_a<<endl;
   }
private:
 int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

这个会报错,因为this是空指针,成员变量存放在类里面,需要通过类的指针进行访问

C语言和C++实现Stack的对比

我们在C语言中,我们使用结构体成员,我们要一般通过写一个函数传入该结构体变量的地址进行访问
C语言版

#include
#include
struct Stack
{
	int* arr;
	int top;//栈顶元素的下一个
	int capacity;
};
void Init(struct Stack* obj)
{
	obj->arr = (int*)malloc(sizeof(int) * 3);
	obj->top = 0;
	obj->capacity = 3;
}
int main()
{
	struct Stack sta;
	Init(&sta);


	return 0;
}

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

c++版

#include
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
	void Init()
	{
		arr = (int*)malloc(sizeof(int) * 3);
		top = 0;
		capacity = 3;
	}
private:
	int* arr;
	int top;//栈顶元素的下一个
	int capacity;
};

int main()
{
	Stack sta;
	sta.Init();
	return 0;
}

c++这里不用传结构体变量的指针,因为编译器帮我们搞定了
C++中通过类可以将数据 以及 操作数据的方法进行完美结合，通过访问权限可以控制那些方法在
类外可以被调用，即封装
C++中 Stack * 参数是编译器维护的，C语言中需用用户自己维护。