C++面向对象编程之类的使用（从struct到class的进阶）

骑猪看日落 2022-11-06 14:54 162阅读 0赞

### 文章目录 ###

*   *  一、结构体的使用
     *  二、由结构体到类
     *  三、C++类的定义与使用
     *   *   *  1、引入类（class）
             *  2、类的基本用法
             *  3、类的访问权限
             *  4、类的成员函数与接口定义

## 一、结构体的使用 ##

**1、C语言中struct的使用**

struct stu1{ 
    	int a;
    	float b[8];
    	double c;
    };

**2、C++中带函数的struct**

struct stu2{ 
    	int ids;
    	int age;
    	char name[10];
    	//C++在结构体中可以定义函数 
    	void pri()
    	{ 
    		cout << "I am " << name << ",age is "  << age << ",id is "  << ids << endl;
    	}
    };

**3、C++中结构体的赋值与调用**

//给C++的结构体赋值
    void load()
    { 
    	stu2 student;  //结构体对象student 
    	student.ids = 12345;
    	student.age = 23;
    	strcpy(student.name, "Chung"); 
    	//调用C++结构体中的函数 
    	student.pri();
    }

## 二、由结构体到类 ##

**1、结构体与类的区别**  
（1）结构体是值类型，类是引用类型

（2）结构体成员不能在声明时赋值初始值，类可以（实际上，C\#类成员初始化代码会被编译器放到构造函数中的最前边部分执行，而C++中根本没有这种方式，只能声明成员）  
不能为结构体提供无参构造函数（类中如果提供了自定义构造函数，就不会再提供默认无参构造函数。）

（3）默认可访问性：结构体的成员默认public，类的成员默认private

（4）结构体可以像类一样通过new 构造函数()来创建实例，也可以声明实例之后再赋值。

（5）结构体在自定义构造函数中必须为所有成员赋值。

（6）结构不允许声明析构函数（Destructor），类则无此限制

（7）结构体成员不能从继承自其他类或结构体，也不能被其他类或结构体继承（但可以实现接口），然而类可以（注意，所有的值类型都默认从ValueType类继承，ValueType类再从Object类继承。所以结构体对象仍然拥有超类Object的成员）。

（8）结构体之间的比较，可以使用Equals，而不能使用==操作符。且当结构体有成员是引用类型时，成员的比较是用 Object.ReferenceEquals 实现，即该引用类型的成员是否指向相同的引用（可能会让人误解，因为使用者可能只是想比较数值相同）

**2、何时使用类何时使用结构体**

*  因为结构体是值类型，自身存储在栈上，主要用于轻量级对象，用来存储简单的数据（此时结构体的成员也大部分是值类型）。
 *  因为类是引用类型，可以抽象、继承等，适合存储重量级对象，拥有复杂逻辑（结构体不能被继承，也不能继承自其他，不能用abstract关键字等）

## 三、C++类的定义与使用 ##

#### 1、引入类（class） ####

其实类和结构体是非常相似的，只是比结构体更具体化。在C++里面，结构体能定义函数，类也能，因此C++中的类与结构体几乎的没有区别的，有时候将struct改为class都没有问题。

类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。

简单来说，类就是将事物抽象成属性和行为，并将其封装在一起的一种引用类型。

#### 2、类的基本用法 ####

#include <iostream> //标准输入输出流
    using namespace std;  //声明一段命名空间 ，且必须定义在全局范围内 
    
    class Who
    { 
    	public:
    		//属性
    		int id;
    		int age;
    		//行为
    		void Who_do()
    		{ 
    			cout << age << "岁大的" << id << "正在睡觉。" << endl; 
    		} 
    };  //结尾id分号一定不能忘记 
    
    int main()
    { 
    	//通过类实例化一个对象 
    	Who People;
    	//默认类中的成员都是私有的，因此不能这样访问：People.age;
    	//结构体中所有的成员默认都是公有的，但类中的成员默认是私有的，加了public才是公有的
    	People.age= 23;
    	People.id= 12345;
    	People.Who_do();  
    }

注意：无论是struct结构体还是class类的定义，都需要在结尾后添加一个分号，代表一条语句的结束。

#### 3、类的访问权限 ####

*  public：共有部分，类内（类中的函数）类外（类的实例化对象）都可以直接访问
 *  protected：保护部分，类外（对象）不能访问；类内（类中函数）可以访问 ，在继承中子类可以访问
 *  private：私有部分， 类外不能访问，类内可以访问 ，在继承中子类不能访问

注意：量设置成员变量为私有权限private，可以给变量设置只读、只写、可读可写等权限，同时给它们在共有public部分设置对应的接口

#### 4、类的成员函数与接口定义 ####

（1）普通函数处理

#include <iostream>
    using namespace std;
    
    class Time  //类Time，用来存放函数变量的 
    { 
    public:
    	int hour;
    	int minute;
    	int sec;
    };
    void set_time(Time&);  //函数声明
    void show_time(Time&); 
    int main() 
    { 
    	Time t1;  //定义Time类的对象t1 
    	set_time(t1);  //传入对象 ，函数接收对象需要用引用类型
    	show_time(t1);
    	Time t2;
    	set_time(t2);
    	show_time(t2);
    	return 0; 
    }
    void set_time(Time &t)  //设置值函数 
    { 
    	cin >> t.hour;
    	cin >> t.minute;
    	cin >> t.sec;
    }
    void show_time(Time &t)  //输出值函数 
    { 
    	cout << t.hour << ":" << t.minute << ":" << t.sec << endl;
    }

（2）使用成员函数处理

#include <iostream>
    using namespace std;
    
    class Time
    { 
    public:
    	void set_time();  //公共成员函数 
    	void show_time();
    private:
    	int hour;
    	int minute;
    	int sec;
    };
    int main()
    { 
    	Time t1;  //对象t2 
    	t1.set_time();
    	t1.show_time();
    	Time t2;
    	t2.set_time();
    	t2.show_time();
    	return 0;
    }
    void Time::set_time()  //在类外定义函数，需要使用::符号
    { 
    	cin >> hour;
    	cin >> minute;
    	cin >> sec;
    } 
    void Time::show_time()
    { 
    	cout << hour << ":" << minute << ":" << sec << endl;
    }

（3）成员函数的接口定义

#include <iostream> //标准输入输出流
    using namespace std;  //声明一段命名空间 ，且必须定义在全局范围内 
    
    class People
    { 
    //在共有部分定义相应的接口 
    public:
    	//对只读属性进行只读访问 
    	int getReadOnly(){ return readOnly;
    	}
    	//对只写属性进行只写访问
    	void setWriteOnly(int lins){ writeOnly= lins;
    	} 
    	//对可读可写属性进行可读可写访问 
    	void setReadWrite(int lins){ readWrite= lins;		
    	}
    	int getReadWrite(int lins){ return readWrite;
    	}
    private:
    	int readOnly;
    	int writeOnly;
    	int readWrite;
    };
    
    int main()
    { 
    	People chung;  //根据类People实例化对象chung
    	chung.getReadOnly();
    	chung.setWriteOnly(123);
    	chung.getReadOnly();
    	chung.getReadWrite(456); 
    }