C++类和对象（一）

c++类和对象 (一)

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。比如洗衣服这个场景：先拿盆子，再防水到盆子中，然后放衣服和洗衣粉，手搓，换水，再手搓，直到水清为止，拧干， 晒衣服。C++语言是面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。总共有四个对象：衣服，人，洗衣机，洗衣粉。

2. 类的定义

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。也可以说C++把C的结构体升级成了类。

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

//实例
struct stack
{
	void Init(int capacity = 5) { //成员函数
		int* tmp = (int*)malloc(sizeof(int) * capacity);
		if (tmp == nullptr) {
			exit(-1);
		}
		_a = tmp;
		_capacity = capacity;
		_size = 0;
	}
	//push/pop/top功能....

	int* _a; //成员变量
	int _size;
	int _capacity;
}; 
//C++中更喜欢用class来代替

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

3. 类的访问限定符

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

访问限定符：public(公有)、protected(保护)、private(私有)

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

见一面

class date
{
public:
	void Init(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}
	void out(date x) {
		cout << x._year << " " << x._month << " " << x._day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

struct和class区别？

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别

4. 类的作用域

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

test.h

class date
{
public:
	void Init(date* x);
	void out(date x, int year, int month, int day);
private:
	int _year;
	int _month;
	int _day;
};

test.cpp

void date::Init(date* x) { //init是属于date这个类域
	date* tmp = (date*)malloc(sizeof(date));
	if (tmp == nullptr) {
		exit(-1);
	}
	x = tmp;
}

void date::out(date x, int year, int month, int day) { //out是属于date这个类域
	x._year = year;
	x._month = month;
	x._day = day;
	cout << x._year << " " << x._month << " " << x._day << endl;
}

5. 类的实例化

用类型创建对象的过程，也就是开空间，称为类的实例化。

1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。

2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。

3. 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

6.计算类的大小

现象

class stack
{
public:
	void Init(int size = 4) {
		int* tmp = (int*)malloc(sizeof(int) * size);
		if (tmp == nullptr) {
			exit(-1);
		}
		_a = tmp;
		_size = 0;
		_capacity = size;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

int main()
{
    stack s1;
	cout << sizeof(s1) << endl;
	return 0;
}
//32位下输出是12，64位下输出16

问题：为什么成员变量是在对象当中，为什么成员函数不在对象中呢？

我们知道函数名是个地址，当程序运行时，是通过地址跳转到对应的函数体的。这里假设我们有多个对象，那么这里每个对象就都会有相应的函数名地址，这样就浪费了内存空间，所以成员函数放在公共区域–代码段

实例

//类的计算方法和C语言中的结构体计算大小方法一样，可以参考我的C语言中相关结构体知识
// 类中既有成员变量，又有成员函数
class A1 {
public:
  void f1(){}
private:
  int _a;
};

class A2 {
public:
 void f2() {}
};

// 类中什么都没有---空类
class A3
{};

//A1大小是4，A2和A3大小都是1

计算类的大小的结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

7. this指针

7.1 引出

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, 2);
	d2.Init(2023, 2, 3);
	return 0;
}

问题：d1和d2对象都调用的同一个函数，怎么知道d1.Init()调用的就是d1的，d2.Init()调用的就是d2的？

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

//暴露隐藏
class date
{
public:
	void Init(date* this, int year, int month, int day) {
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	date d1;
	date d2;
	d1.Init(&d1,2023, 2, 2);
	d2.Init(&d2,2023, 2, 3);
	return 0;
}

用法

class date
{
public:
	void Init(int year, int month, int day) {
		this->_year = year; //可以在成员函数内部使用，不能在形参使用
		this->_month = month;
		this->_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	date d1;
	date d2;
	d1.Init(2023, 2, 2);
	d2.Init(2023, 2, 3);
	return 0;
}

7.2 特性

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

观察：this指针由编译器通过ecx寄存器自动传递（也就是ecx寄存器来存放对象的地址）

上述现象中看出既然成员函数不是存放在对象中，那么this指针是存放在哪里呢？

this指针是存放在栈上的，因为this是一个隐含的指针形参。

this既然是个指针，那么可以为空吗？

（* p).fun();也是可行的，这里的fun()成员函数不是在对象里面的，是在公用区域–代码段里面的， 所以这里的* p不需要解引用，因为不用在这个对象中找，所以就在代码段中运行，这里的* p的真正的意义是传递给this指针，让编译器知道这个fun()是date类的成员函数，p->fun()也是如此。有没有解引用的行为取决于访问的内容在不在对象中，而不是用没有解引用的符号(*或者->)

this指针使用的场景

class date
{
public:
	void Init(int year, int month, int day) {
		this->_year = year; //this是nullptr并且解引用导致崩溃
		this->_month = month;
		this->_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	date* p = nullptr;
	p->Init(2022, 2, 2);
	return 0;
}
//运行崩溃

为什么运行崩溃？

p是一个空指针，当进入Init成员函数时，此时的this指针是一个nullptr，下面的this->_year、this->_month、this->_day都是对指针进行解引用，空指针解引用出现错误。

8. 类的封装

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

封装的概念：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装的本质：封装本质上是一种管理，让用户更方便使用类

比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

C和C++区别

1. C语言是数据（结构）和方法（函数）是分离的，但是C++是数据（结构）和方法（函数）都放在类里。
2. C语言数据访问是自由的，不受限制（可以直接访问，也可以封装函数间接访问），但是C++数据访问方式是受限制的，有类访问限定符可以设置公有、私有、保护。

C语言数据访问自由实例

//C实现栈
typedef int stackType;
struct stack
{
	stackType* a;
	int top;
	int capacity;
};

stackType stackTop(stack s) {
	return s.a[s.top];
}

//访问栈顶元素(访问不受限制，但是用第一种方式必须了解底层实现且不安全)
1.int top = s.a[s.top];
2.satck s; int top = stackTop(s);

C++语言数据访问实例

typedef int stackType;
class stack
{
public:
	stackType stackTop(stack s) {
		return s.a[s.top];
	}

private:
	stackType* a;
	int top;
	int capacity;
};
//数据是私有的，不能直接访问，但是方法（函数）是公有的，可以直接访问使用