C++类与对象 (上）

目录

前言：

类和对象的理解

类的引入

类的定义与使用方式

访问限定符

类的两种定义方式

成员变量的命名规则

类的作用域

类的实例化

类对象模型

计算类对象的大小

类对象的存储方式

this指针

前言：

• C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题；
• C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成；

类和对象的理解

类是一个抽象的概念，描述了一类对象的共同属性和行为；

对象是类的具体化，它是类的实例，具有类中定义的属性和行为；

在C++中，类通常由数据成员和成员函数组成，数据成员是类的属性，它们描述了对象的状态，成员函数是类的行为，它们描述了对象可以执行的操作，对象的创建是通过类的实例化来完成的，当程序需要使用类时，可以通过创建类的对象来使用类的属性和行为；

举例如下：

将“汽车”看作一个类，在这个类中定义了汽车的属性和行为，比如颜色、品牌、速度等属性，以及加速、刹车、转弯等行为；当我们要描述具体一辆汽车时，就需要创建一个该类的对象，并根据需要设置其相应的属性值或对其进行行为操作；

类的引入

由于C++兼容C语言中struct的所有用法，同时C++对关键字struct进行了升级，将struct升级为类；

• ?struct? ? 类名 （类名即为变量类型）

//c语言
struct Stack
{
	int* a;
	int top;
	int capacity;
};
int main()
{
	//Stack s1; //C语言 ---> 未定义的标识符
	struct Stack s1;//只能采取带上struct关键字定义变量
	return 0;
}
//c++ 
struct Stack
{
	int* a;
	int top;
	int capacity;
};
int main()
{
	Stack s1;//可直接采取这种方案定义变量,不需要加上struct的关键字
	return 0;
}

//c语言定义链表结点
struct ListNode
{
  //ListNode* next;//C语言 ---> 未定义的标识符
  struct ListNode* next;
	int val;
};
//c++定义链表结点
struct ListNode
{
    ListNode* next;//编译通过
	int val;
};

• C++结构体中可以定义函数；

//c++ 类里面可以定义函数
struct Stack
{
	int* a;
	int top;
	int capacity;
	//初始化栈
	void Init()
	{
		a = 0;
		top = 0;
		capacity = 0;
	}
};

?C++用关键字 class 代替 struct；

类的定义与使用方式

class 类名
{

   //类体: 由成员变量与成员函数组成

}; //此处分号不可省略

类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法或成员函数；

访问限定符

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

?访问限定符说明：

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

class Stack
{
private:
	int* a;
	int top;//a,top,capacity--->成员变量私有
	int capacity;
    //private的作用域从private开始到public,若没有public,直接到类结束;
    //由于class的默认访问权限为私有，省略掉private,三个成员变量依旧私有
public:
	//初始化栈
	void Init()// Init()函数公有
	{
		a = 0;  
		top = 0;
		capacity = 0;
	}
}; //类结束

类定义的惯例：成员变量私有，成员函数公有；

class Stack
{
public:
	int* a;
	int top;
	int capacity;
	//初始化栈
	void Init()
	{
		a = 0;  
		top = -1;
		capacity = 0;
	}
	//空栈的判断
	bool StackEmpty()
	{
		return (top == -1);
	}
}; 
int main()
{
	Stack s1;
	s1.Init();
	//判断方式1:空栈, 若top=0,表示指向栈顶元素的下一个位置;
	//         空栈, 若top=-1,表示指向栈顶元素的位置;
	//栈的定义方式不同，如下判断方法可能导致出错;
	if (s1.top==0)
    
   //判断方式2:采取访问成员函数进行判断，直接调用判空函数,不会出错
	if (!s1.StackEmpty())
	{

	}
	//如上就是成员变量私有,成员函数公有的原因
	return 0;
}

类的两种定义方式

定义方式1：类的声明放在.h文件中，成员函数定义放在.cpp文件中；

??????????????????? (注：成员函数名前加 类名 ::)

定义方式2：声明和定义全部放在类体中；

????????????????? （注：成员函数如果在类中定义，编译器可能会将成员函数当成内联函数处理）

成员变量的命名规则

class Date
{
public:
	void Init(int year,int month,int day)
	{
		// 这里的year到底是成员变量，还是函数形参？
		year = year;
		//局部优先，year为函数形参
		//局部优先是指在函数内部创建了一个和全局变量同名的局部变量时;
		//函数内部对该变量的操作会优先作用于局部变量，而不会改变全局变量的值
	}
private:
	int year;
	int month;
	int day;
};

为了避免如上情形，C++采用成员变量前加 _

class Date
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
	}
private:
	int _year;
	int _month;
	int _day;
	//year month day成员变量前加 _
};

类的作用域

类 定义了一个 新的作用域， 类的所有成员都在类的作用域中；

在 类体外定义成员时，需要使用 ::作用域限定符指明成员属于哪个 类域；

c++中由{ }所定义的皆为作用域；

class Stack
{
  //变量的声明，没有在内存中开辟空间
	int* a;
	int top;
	int capacity;
public:
	void Init();
	bool StackEmpty();
};
//需要指定Init()函数属于Stack类域
void Stack::Init()
{
	a = 0;
	top = 0;
	capacity = 0;
}

class Date
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
	}
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date::_year = 2023;//编译错误,成员变量为声明,没有开辟内存空间存储;
   // Date d; d.year=2023  //正确做法
	return 0;
}
//Date类是没有空间的，只有Date类实例化出的对象才有具体的年份

# include <iostream>
using namespace std;
class Date
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
	}
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d;
	cout << sizeof(d) << endl;
	return 0;
}

类对象的存储方式

类对象的存储方式：

对象中只保存成员变量，成员函数存放在公共代码段，这种方式将类的成员变量存储在对象中，而将成员函数存放在公共代码段中，通过对象来访问类的成员函数；

结论：一个类的对象大小，实际就是该类中”成员变量”之和，注意考虑内存对齐 ；

空类的大小：空类的大小为1字节；即使一个类没有任何成员变量和成员函数，它也会占用1字节的内存空间；

空的结构体大小：空的结构体大小为0字节，与空类不同，空的结构体不占用任何内存空间；

//类中仅有成员函数--->1byte
//对象中无成员函数
class B
{
public:
	void f2() {}
};
int main()
{
	B b;
	cout << sizeof(b) << endl;
	return 0;
}

//空类的大小 ---> 1byte
//无成员变量的类开辟1个字节，该字节不存储有效数据
//标识定义的对象存在过
class C
{

};
int main()
{
	C c;
	cout << sizeof(c) << endl;
	return 0;
}

this指针

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(2023, 12, 17);
	d2.Init(2023, 12, 16);
	d1.Print();
	d2.Print();
	return 0;
}

运行结果：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，d1调用的Print()函数与d2调用的Print()函数相同，那当d1调用Print()函数时，该函数是如何知道应该显示d1对象，而不是显示d2对象呢？

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

this指针的特性：

1. this指针的类型：类型* const ，由于const修饰this，this指针不允许被修改；
2. 只能在“成员函数”的内部使用 （不能显示的写实参和形参，但是可以在类中显示的使用）；
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参，所以对象中不存储this指针；
4. ?this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递 ；