【C++】类和对象1（访问限定符、作用域、类对象）

灰太狼 2021-09-08 23:16 434阅读 0赞

### 文章目录 ###

*  前言
 *  一、类的引入
 *  二、类的定义
 *  三、类的访问限定符及封装
 *   *  1.访问限定符
     *  2.封装
 *  四、类的作用域
 *  五、类对象模型
 *   *  1.如何计算类对象的大小
     *  2.类对象的存储方式猜测
     *   *  （1）类实例化出的对象中包含所有成员
         *  （2）类实例化出的对象中只保存成员变量，成员函数存放在公共的区域（代码段）
 *  感谢阅读，如有错误请批评指正

--------------------

# 前言 #

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

--------------------

# 一、类的引入 #

C语言中，结构体中只能定义变量。

**C++中，结构体内不仅可以定义变量，也可以定义函数。C++中的struct兼容C的所有用法**，同时C++中把struct升级为类。且C++中类名就可以直接当成一个类型，不需要在前面加struct。

代码如下（示例）：

struct student
    { 
    	//给默认值（也可以是其他）
    	void Init(const char* name = "张三", const char* id = "0000", const int age = 18)
    	{ 
    		strcpy(_name, name);
    		strcpy(_id, id);
    		_age = age;
    	}
    
    	void Print()
    	{ 
    		cout << _name << endl;
    		cout << _id << endl;
    		cout << _age << endl;
    		cout << endl;
    	}
    
    	char _name[10];
    	char _id[10];
    	int _age;
    };
    
    int main()
    { 
    	struct student s1;//struct student与student的效果相同
    	s1.Init("李四", "1234", 20);
    	s1.Print();
    
    	student s2;
    	s2.Init();
    	s2.Print();
    
    	return 0;
    }

运行结果如下  
![在这里插入图片描述][20210707153557202.png_pic_center]  
用类这一类型创建对象的过程，称为类的实例化。

类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储成员变量。

一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间。

**注意：类中\_name、\_id、\_age三个成员变量只是声明，还没有为它们开辟空间，只有在main函数中实例化（定义）出s1、s2两个对象后，这两个对象的三个成员变量才真正定义出来；但类中的成员函数是定义。**

--------------------

上面结构体的定义，在C++中更喜欢用class来代替。

仅需把上面代码中定义struct student时的struct改为class即可。

代码如下（示例）：

class student
    { 
    	//...
    };
    
    int main
    { 
    	//...
    }

但修改后上面main函数中的程序就编译不过了，为什么呢？

注意：**struct定义的类中的成员函数和成员变量默认是public，class定义的类中的成员函数和成员变量默认是private**（关于public和private后面会介绍）。

--------------------

# 二、类的定义 #

代码如下（示例）：

//该类的名称为className或class className
    class className
    { 
    	//类中的内容由成员函数和成员变量组成
    	//...
    };//与结构体一样，一定要注意后面的分号

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

类中的元素称为类的成员：类中的数据称为类的成员变量; 类中的函数称为类的成员函数。

类的两种定义方式：  
1.声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器**可能**会将其当成内联函数处理。  
2. 声明放在.h文件中，类的定义放在.cpp文件中。

--------------------

# 三、类的访问限定符及封装 #

## 1.访问限定符 ##

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

访问限定符包括三个：public，private，protected；

说明：  
1.public修饰的成员在**类的外面可以直接被访问**。  
2.protected和private修饰的成员在**类的外面不能直接被访问**(目前认为protected和private是一样的，两者不同之处会在后面的文章中讲到)。  
3.**访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时或类结束为止**。  
4.**class的默认访问权限为private，struct为public(因为struct要兼容C)**。

于是只要把上面的代码如下修改，便可正常运行

代码如下（示例）：

class student//用class定义类
    { 
    //外部可调用public内的Init和Print函数
    public:
    	void Init(const char* name = "张三", const char* id = "0000", const int age = 18)
    	{ 
    		strcpy(_name, name);
    		strcpy(_id, id);
    		_age = age;
    	}
    
    	void Print()
    	{ 
    		cout << _name << endl;
    		cout << _id << endl;
    		cout << _age << endl;
    		cout << endl;
    	}
    //外部不可访问private内的三个成员变量
    private:
    	char _name[10];
    	char _id[10];
    	int _age;
    };
    
    int main()
    { 
    	class student s1;
    	s1.Init("李四", "1234", 20);
    	s1.Print();
    
    	student s2;
    	s2.Init();
    	s2.Print();
    
    	return 0;
    }

在类设计中，希望在类外被访问的（一般是成员函数）定义为public，不希望在类外被访问的（一般是成员变量）定义为private或protected。

--------------------

## 2.封装 ##

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

在类和对象阶段，我们只研究类的封装特性，即将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理。通过类数把据和方法都封装到一起。不想给访问的，我们使用  
protected/private把成员封装起来。开放一些共有的（public）成员函数对成员进行合理的访问。所以封装本质是一种管理。

--------------------

# 四、类的作用域 #

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

上面的类可以修改为下面的代码

代码如下（示例）：

class student
    { 
    public:
    	//class中放函数的声明
    	void Init(const char* name = "张三", const char* id = "0000", const int age = 18);
    	void Print();
    
    private:
    	char _name[10];
    	char _id[10];
    	int _age;
    };
    
    //在外面实现函数（一般放在.h文件中）
    //加::表明函数在student类域中
    void student::Init(const char* name, const char* id, const int age)//默认值在函数声明时给出
    { 
    	strcpy(_name, name);
    	strcpy(_id, id);
    	_age = age;
    }
    
    void student::Print()
    { 
    	cout << _name << endl;
    	cout << _id << endl;
    	cout << _age << endl;
    	cout << endl;
    }

--------------------

# 五、类对象模型 #

## 1.如何计算类对象的大小 ##

以上面的student类为例

代码如下（示例）：

class student
    { 
    public:
    	void Init(const char* name = "张三", const char* id = "0000", const int age = 18)
    	{ 
    		strcpy(_name, name);
    		strcpy(_id, id);
    		_age = age;
    	}
    
    	void Print()
    	{ 
    		cout << _name << endl;
    		cout << _id << endl;
    		cout << _age << endl;
    		cout << endl;
    	}
    	
    private:
    	char _name[10];
    	char _id[10];
    	int _age;
    };

很容易计算出三个成员变量占用24个字节（这里注意算类的大小也要内存对齐，内存对齐具体可在[自定义类型（一）：结构体][Link 1]中查看），那么问题来了，计算类的大小时需要计算成员函数吗？如果需要，又改怎么计算呢？

--------------------

## 2.类对象的存储方式猜测 ##

### （1）类实例化出的对象中包含所有成员 ###

缺陷：每个对象中成员变量是不同的，但是调用的成员函数是同一个，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存相同的函数，相同代码保存多次，浪费空间。这是不合理的。

### （2）类实例化出的对象中只保存成员变量，成员函数存放在公共的区域（代码段） ###

如果采用这种存储方法，每个对象的成员变量不同，代表各自独立的信息，而调用的函数是一样的，可以尽可能的节省空间。这也是实际的存储方式。

--------------------

下面看一些特殊情况：

代码如下（示例）：

// 类中既有成员变量，又有成员函数
    class c1 { 
    public:
    	void f()
    	{ }
    private:
    	int _a;
    };
    
    // 类中仅有成员函数
    class c2 { 
    public:
    	void f() 
    	{ }
    };
    // 类中什么都没有---空类
    class A3
    { 
    
    };

上面的代码中c1的大小为4，只计算成员变量\_a的大小即可。

但c2、c3的大小是0吗？  
不是。它们的大小都为1。如果大小是0，它们就没有地址，无法区分，**所以大小为1不是为了存数据，仅仅是为了占一个唯一的地址，表示这个类存在**。

--------------------

# 感谢阅读，如有错误请批评指正 #

[20210707153557202.png_pic_center]: /images/20210813/da2cdf2bb8c54b15b0271f2691abf5fc.png
[Link 1]: https://blog.csdn.net/weixin_51983604/article/details/115298310?spm=1001.2014.3001.5501