C++类和对象（上）

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

下面就拿洗衣服这个例子来解释一下面向对象和面向过程的区别。

面向过程：

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

面向对象：

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

2. 类的定义

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。但我们一般直接用关键字class来进行类的定义

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

举个栗子：

struct A //A->类名
{
	//成员函数
	int Add(int x, int y)
	{
		return x + y;
	}
	//成员变量
	int _a;
	int _b;
};
//一般用class关键字来定义类
class A //A->类名
{
	//成员函数
	int Add(int x, int y)
	{
		return x + y;
	}
	//成员变量
	int _a;
	int _b;
};

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

3. 类的访问限定符

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

class中有三种访问限定修饰符：

1. public 共有，被修饰的成员在类外可以直接访问

2. protected 保护，被修饰的成员能在类中和其派生类中被访问，在类外不能被直接访问

3. private 私有，被修饰的成员只能在类中访问

注意：

1. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

2. 如果后面没有访问限定符，作用域就到 } 即类结束

3. class的默认访问权限为private，struct为public(因为struct要兼容C)

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

举个栗子：

class A
{
//共有
public:
	int Add(int x, int y)
	{
		return x + y;
	}
//保护
protected:
	int _a;
//私有
private:
	int _b;
	int _c;
};

C++中 struct 和 class 的区别：

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

4. 类的作用域

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

//.h文件中
class A
{
public:
	int Add(int x, int y);

	int Sub(int m, int n);
private:
	int _a;
	int _b;
	int _c;
};
//.cpp文件中
int A::Add(int x, int y)
{
	return x + y;
}

int A::Sub(int m, int n)
{
	return m - n;
}

5. 类的实例化

用类类型创建对象的过程，称为类的实例化

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

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

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

6. 类的大小

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

既然不是存储在类中，那么计算类的大小时只用计算类成员变量的大小就行了，类的大小计算也同样遵循C语言内存对齐那套规则

举个栗子：

class A {
public:
	void test1() {}
	void test2() {}
private:
	int _a;
	char _b;
};

class B {
public:
	void test() {}
};

//空类
class C
{};

int main()
{
	A aa;
	B bb;
	C cc;
	cout << sizeof(aa) << endl; //8
	cout << sizeof(bb) << endl; //1
	cout << sizeof(cc) << endl; //1
	return 0;
}

结论：

类的大小实际上就是该类中“成员变量”大小之和，同样遵循C语言结构体内存对齐的规则，有个特殊是空类，编译器赋予了空类一个字节的大小来标识这个类

7. this指针

7.1 this指针的引出

我们先来定义一个简易的日期类来引出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(2003, 4, 12);
	d2.Init(2003, 4, 13);
	d1.Print();
	d2.Print();
	return 0;
}

疑问：这里d1和d2两个不同的对象掉用的都是同一个函数，那怎么确定d1.Init()调用的就是d1的，d2.Init()调用的就是d2的呢？

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

上面的日期类实际的样子：

//暴露this指针
class Date
{
public:
	void Init(int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

7.2 this指针的特性

1. this指针的类型：类的类型 const*，即成员函数中，不能给this指针赋值

2. 只能在“成员函数”的内部使用

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

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

5. this指针是一个隐含的指针形参，是存放在栈的，一般通过ecx寄存器自动传递

6. 可以存在指向空的对象指针，通过此指针调用函数时，只要不发生this解引用的情况，是不会报错的，因为此时this指针为空指针

this指针由编译器通过ecx寄存器自动传递（ecx来存放地址）：

this指针为空：

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

8. 类的封装

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

---

封装的概念：

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

封装的本质：

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

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

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用

C语言和C++的区别：

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

访问数据实例：

//C实现栈
struct stack
{
	int* a;
	int top;
	int capacity;
};
//访问栈顶元素
//方法一：直接访问
stack st
int top = st.a[s.top];

//方法二：使用函数
int Top(stack st);
int Top(stack st) {
	return st.a[s.top];
}
//访问不受限制，但是用第一种方式必须了解底层实现且不安全)

//C++实现栈
class stack
{
public:
	int Top(stack st) {
		return st.a[st.top];
	}

private:
	int* a;
	int top;
	int capacity;
};
//访问栈顶元素：
stack st;
int top = st.Top(st);
//数据是私有的，不能直接访问，但是方法（函数）是公有的，可以直接访问使用

---

C++类和对象（上）到这里就介绍结束了，本篇文章对你由帮助的话，期待大佬们的三连，你们的支持是我最大的动力！

文章有写的不足或是错误的地方，欢迎评论或私信指出，我会在第一时间改正