《c++从0到99》 二 类和对象 上

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

C语言是面向过程的，所谓面向过程就是分析出解决问题所需要的具体步骤，然后用函数把这些步骤一个个实现出来。使用的时候一个个调用就可以了；
而C++是基于面向对象的，所谓面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成某一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

01 面向过程的优缺点

• 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
• 缺点：相比面向对象不易维护、复用、扩展。

02 面向对象的优缺点

• 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
• 缺点：相比面向过程性能较低。

2. 什么是类

在c语言中结构体struct只能定义变量，而在c++中，struct不仅可以定义变量，也可以定义函数。

struct Student
{
void SetStudentInfo(const char* name, const char* gender, int age)
{
strcpy(_name, name);
strcpy(_gender, gender);
_age = age;
}
void PrintStudentInfo()
{
cout<<_name<<" "<<_gender<<" "<<_age<<endl;
}
char _name[20];
char _gender[3];
int _age;
};

在c++中struct通常用class代替，也就是c++中的类。

3. 类的定义

class className
{
// 类体：由成员函数和成员变量组成
}; // 注意分号

其中：

• class是c++定义类的关键字
• calssName是类的名字
• {}内的元素为类的成员，类的成员一般有：成员变量和成员函数。
• 类中的数据被称为类的属性或者成员变量
• 类中的函数被称为类的方法或类的成员函数

类的俩种定义方式

01 声明和定义全在类中

注意：成员函数在类中定义可能会被编译器按照内联函数处理。

// 声明和定义全在类中。
class Student
{
public:
	void showinfo()
	{
		cout << name << sex << age << addr << endl;
	}
private:
	char* name;
	char* sex;
	int age;
	char* addr;
}

02 声明放在.h文件中，定义放在.cpp文件中

• 声明文件放在student.h中

class Student
{
public:
	void showinfo();
private:
	char* name;
	char* sex;
	int age;
	char* addr;
}

• 定义文件放在student.c中

#include <student.h>
void Student::showinfo()
{
	cout << name << sex << age << addr << endl;
}

通常情况下采用这种方法。

4. 类的访问限定符以及封装

01 访问限定符

c++用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用，这就是类的封装
类的访问限定符有：

• public（公有）
• protected（保护）
• private（私有）

注意：

1. public所修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问。
3. 访问权限作用域从该访问限定符出现的位置开始到下一个访问限定符出现时为止。
4. class的默认访问权限为private，struct为public。（c++中class和struct）的区别。
5. 类的作用域限定符在编译时有用，映射到内存后，将没有访问限定符伤的区别

02 封装

什么是封装？：

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

封装本质上是一种管理：我们如何管理兵马俑呢？比如如果什么都不管，兵马俑就被随意破坏了。那么我们首先建了一座房子把兵马俑给封装起来。但是我们目的全封装起来，不让别人看。所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种数据和代码的管理。

5. 类的作用域

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

class Person
{
	public:
	void PrintPersonInfo();
	private:
	char _name[20];
	char _gender[3];
	int _age;
};
// 需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout<<_name<<" "_gender<<" "<<_age<<endl;
}

6. 类的实例化

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

1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类但并没有分配实际的内存空间来存储它
2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，用来存储类成员变量

7. 类的对象大小的计算

在计算类的大小之前，首先我们要知道类与对象的关系：对象是类的实例化。类是模型不占空间，实例化的对象才占空间。
在类的对象中，一个类的大小实际就是该类中成员变量之和。在求和时要注意内存对齐。

#include<iostream>
using namespace std;
class Student
{
public:
	void GetScore();
private:
	char _name[20];
	char _sex[4];
	int _age;
	int _score;
};
void Student::GetScore()
{
	
}
int main()
{
	cout << sizeof(Student) << endl;
	return 0;
}

这个类中既有成员变量，又有成员函数，但是在求类的大小时，只需将类中的成员变量相加，再进行内存对齐即可。所以所占内存大小为：

空类型所占内存空间大小（VS2017）：

#include<iostream>
using namespace std;
class A
{

};
int main()
{
	cout << sizeof(A) << endl;
}

既然类为空，那我们想当然的认为这个类的大小为0；其实不然，该空类的结果在vs2017中为：
可以看出空类的内存所占大小为1字节而非0，这是因为c++中，规定任何不同的对象不能拥有相同的内存地址。 也就是说，如果空类不占大小的话，那么同一类定义出多个对象后就会无法分辨出地址，且在C++中规定了任何不同的对象不能拥有相同的内存地址，所以编译器给了空类一个字节来唯一标识这个类。所以空类的内存所占大小在vs2017编译环境下为1字节。

内存对齐规则：

1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
   注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
   VS中默认的对齐数为8
3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是
   所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

8. 类的存储方式

类的存储还是很好理解的
在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上。

1.非静态成员函数肯定是所有对象共享的，不属于某一个特定的对象
2.静态成员变量存储在全局区（静态区），它在运行前编译器就已经为其开辟好存储空间，不可能于类的对象存储在一起。
3.静态成员函数存储在代码区，和非静态成员变量存储的内存段是一样的。
4.非静态成员变量存储在栈上，属于类的对象上。
总结：计算一个类的对象在内存中所占字节数，就是计算非静态成员变量总和在内存中所占字节数。（注意内存对齐规则）

9. 类成员函数的this指针

01 什么是this指针

我们先定义一个日期类：

class Date
{
 public :
	void Display ()
{
	cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
	void SetDate(int year , int month , int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 private :
	int _year ; // 年
	int _month ; // 月
	int _day ; // 日
};
int main()
{
	Date d1, d2;
	d1.SetDate(2018,5,1);
	d2.SetDate(2018,7,1);
	d1.Display();
	d2.Display();
	return 0;
}

对于上述类，有这样的一个问题：
Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

02 this指针的特性

1. this只能在成员函数中使用。 全局函数、静态函数都不能使用this.
   在实际上，成员函数默认第一个参数为T * const this。

 class A
 {
  public:
     int func(int p)
     {
     }
 };

其中，func的原型在编译器看来应该是：

  int func(A * const this,int p);

由此可见，this在成员函数的开始前构造，在成员函数的结束后清除。
当调用一个类的成员函数时，编译器将类的指针作为函数的this参数传递进去。如：

A a;
a.func(10);

此处，编译器将会编译成：

A::func(&a,10);

2. this 指针会因编译器不同而有不同的存储位置，可能是械、寄存器或全局变量 。
3. this 是类的指针 。
4. 因为 this 指针只有在成员函数中才有定义，所以获得一个对象后，不能通过对象使用 this 指针，所以也就无法知道一个对象的 this 指针的位置。 不过，可以在成员函数中指定this 指针的位置 。
5. 普通的类函数（不论是非静态成员函数，还是静态成员函数）都不会创建一个函数表来保存函数指针，只有虚函数才会被放到函数表中。

以上就是这篇文章的所有内容啦，感谢老铁有耐心看完。有啥错误请多多指正哈！码字不易，希望大佬们点个赞