【c++基础（二）】类和对象（上）

1.前言

C语言是面向过程的语言关注的是过程
而C++是面向对象的语言关注的是对象

而类和对象就是面向对象的基础！

C++为了兼容C语言，保留了原先的玩法,并且增加了新的玩法。

本章重点

本篇文章着重讲解类的概念,基本特性
成员函数的性质,和最重要的this指针

2.什么是面向对象，什么是面向过程呢？

面向对象一般和面向过程结合来看的

面向过程（Procedure Oriented 简称 PO）：把事情拆分成几个步骤（相当于拆分成一个个的方法和数据），然后按照一定的顺序执行。

面向对象（Object Oriented 简称 OO）：面向对象会把事物抽象成对象的概念，先抽象出对象，然后给对象赋一些属性和方法，然后让每个对象去执行自己的方法。

举例：用洗衣机洗衣服，来看一下两者的差别。

面向过程：

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

成。

2.1 面向对象和面向过程的优缺点对比

面向过程：

优点：效率高，因为不需要实例化对象。

缺点：耦合度高，扩展性差，不易维护（例如：每个步骤都要有，不然就不行）

面向对象：

优点：耦合低（易复用），扩展性强，易维护，由于面向对象有封装、继承、多态性的特点，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。(这三大特性后面再讲 )

缺点：效率比面向过程低。

但是在实际的应用过程中，这两者都是混合使用的，但是面向对象用的更多，因为这样可以降低代码的耦合度，有更强的扩展性，也易于维护。

3.类的引入

在c语言中，struct的功能比较单一，只能够定义变量。

typedef struct Quene
{
	QNode* phead;//找到头，从头出
	QNode* ptail;//找到尾，从尾进
	int size;//具体进入多少个数据，到时候要知道进入的个数，省的去遍历一遍
}Quene;

而在c++中，不仅能够在类里面定义变量，还可以在类里面定义函数

struct Lukky
{
	int a;
	char b[20];
	void test()//成员函数
	{
		cout<<"njust"<< endl;
	}
	void push(char ch,int i)//成员函数
	{
		b[i] = ch;
	}
};

int main()
{
	Lukky tmp;
	tmp.test();//会打印"njust"
	tmp.push('a',1);//数组b下标为1的位置会被插入一个字符'a'
}

在C++中,C的结构体struct就是类，但是C++中更喜欢用class替代struct

4.类的定义

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

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

号不能省略 。

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

成员函数 。

类成员的两种定义方式

1.声明和定义都放在类中

clss Person
{
public:
    char* _name;//名字
    char * _sex;//性别
    int _age;//年龄
public:
    void Show()
    {
        cout<<"name: "<<_name<<" sex: "<<_sex<<" age"<<_age<<endl;
    }
};

注意：如果把定义放在类内的话，编译器可能把他当成内联函数来处理，在某个位置直接展开。

2.声明和定义分离

分离就是指类声明放在 .h 文件中，成员函数定义放在 .cpp 文件中。

.h文件

class people
{
	char* name;
	char* sex;
	int height;
	int age;
	void peoinfo()//打印此人的消息
};

.cpp文件（错误示例）

void peoinfo()//打印此人的消息
	{
		cout<<name<<" "<<sex<<" "<<height<<" "<<age;
	}

注意:在另一个文件中,必须要加上类名::
否则系统不知道你是要新定义一个函数，还是要定义已经声明过的函数

.cpp（正确示例）

void people::peoinfo()//打印此人的消息
	{
		cout<<name<<" "<<sex<<" "<<height<<" "<<age;
	}

5.类的访问限定符

5.1 访问限定符

访问限定符说明：

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

2. protected 和 private 修饰的成员在类外不能直接被访问 ( 此处 protected 和 private 是类似的 )

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

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

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

class Ktty
{
public:
	void test1()
	{
		cout<<"i am a student";
	}

	void test2()
	{
		cout<<"hello world";
	}

private:
	int a;
	char b[10];
}

int main()
{
	Ktty tmp;
	tmp.test1();//正常运行
	tmp.a = 10;//运行报错
	return 0;
}

此类中,public和private之间的成员是共有的,类外可以访问
private到类结束的成员是私有的,类外不能访问!但是在类内，成员函数是可以访问成员变量的。（这里不管他们是公有还是私有，都可以在类内被访问）

5.2类的实例化

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

1. 类是对对象进行描述的 ，是一个 模型 一样的东西，限定了类有哪些成员， 定义出一个类并没

有分配实际的内存空间来存储它 ；比如：入学时填写的学生信息表，表格就可以看成是一个

类，来描述具体学生信息。

类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。

谜语： " 年纪不大，胡子一把，主人来了，就喊妈妈 " 谜底：山羊

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

int main()
{
 Person._age = 100;   // 编译失败：error C2059: 语法错误:“.”
 return 0;
}

Person类是没有空间的，只有用Person类实例出的对象才有空间。

3. 做个比方。 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图 ，只设

计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象

才能实际存储数据，占用物理空间

5.3类对象模型

怎么计算一个class类的大小?

class A
{
	void PrintA()
	{
		cout << a << endl;
	}
	int a;
	char b;
};

class B
{
	int a;
	char b;
};

int main()
{
	printf("类A的大小: %d\n", sizeof(A));
	printf("类B的大小: %d\n", sizeof(B));
	return 0;
}

结论：

1. 类中的成员函数不算在类的大小中
2. 类的大小遵守结构体内存对齐规则
3. 空类(没有成员变量)的大小是1字节

5.3.1补充内存对齐规则

1. 第一个成员在与结构体偏移量为 0 的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

VS 中默认的对齐数为 8

3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整

体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

为什么要有内存对齐规则呢？

原因1:平台原因(移植原因)：
不是所有的硬件平台都能访问
任意地址上的任意数据的
某些硬件平台只能在某些地址处取
某些特定类型的数据，否则抛出硬件异常

原因2:性能原因
如果不存在内存对齐的话
平台4个字节4个字节的访问
long long类型的数据时有可能需要
读取两次才能取到一个数据

总的来说:内存对齐是拿空间换取时间

节省空间的技巧:
发现同样的成员类型和数量
成员放的位置不同,结构体大小
也存在的很大的区别

在写结构体时尽量将占用空间
小的数据集中在一起能节省空间

5.3.2类对象的存储模式

为啥类中的成员函数不占空间?
那函数存储在什么位置?

带着这样的疑惑来看看类的存储模式:

• 类成员变量存储在实例化对象中
• 类成员函数存储在公共的代码段

用下图来理解：

成员变量的解释：由于每一个对象中的变量的值可能不同所以成员变量存储在不同的对象中

成员函数的解释：（这里指的是一个类实例出多个对象）但是每个对象调用的函数是相同的
为了节省空间,将成员函数从对象中剥离到公共代码段,不管实例化多少个对象，只要调用成员函数就会去代码段找!

6.this指针

先看以下的日期类:

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;
	d1.Init(2023,7,22);//初始化对象
	return 0;
}

看似Init只有三个参数
看似调用Init时只传了三个参数

但其实还有一个隐藏的指针this!

可以用下图理解this的位置:

并且在每一个成员变量之前，都有对应this指针解引用访问它:这也能够解释为什么当你实例出了多个对象时，编译器怎么知道是哪个对象调用的这个函数。

实际上每个对象调用成员函数时，都会隐式的把自己的地址传给this指针，然后通过this指针来对其他成员的访问

 6.1 this指针的特性

基本特性:

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

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

3. this指针不能我们显示去写
   也不能我们显示去传对象地址

4. this指针存储在栈区,不存储在对象中

6.2 this指针的用处

总结起来就是一句话：使用this指针将对象的地址传入函数中函数体就可以区分不同对象了!

7.总结与拓展

本章是类和对象的入门篇
只介绍了类的解基本概念和特性
其中比较重要的是this指针
它还会陪伴我们很久!

基础不牢,地动山摇
类学不会,学C++就受罪。所以各位小伙伴一定要好好的学习类哟！

8.拓展-c++命名方式

C++又很多习惯的命名方式
这里介绍一个:驼峰法命名

• 单词和单词之间首字母大写
• 函数名,类名首字母大写
• 变量首字母小写,后面单词首字母大写
• 成员变量的首字母前加下划线_

举例说明：

class Date
{ 
public:
  void InitDate(int year, int month, int day)//initialize date
  {                                          //初始化日期,简写后,I和D要大写
    _year = year;
    _month = month;
    _day = day;
  }
  void PrintInfo()//printf information,简写后P和I要大写
  {
    cout <<_year<< "-" <<_month << "-"<< _day <<endl;
  }
private:
  int _year; //成员变量前面加_
  int _month;
  int _day;     
};

                                                      下期预告：类和对象中