学生信息转换（转换构造函数）

任务描述

本关任务：设计学生和教师两个类，并实现它们之间的转换。

相关知识

为了完成本关任务，你需要掌握友元函数、友元类以及转换构造函数。

友元函数

有时候我们希望某个函数能访问一个类的非公有成员，但又不想把它做成这个类的成员函数，这个时候就可以使用友元。

如果要将一个函数变成一个类的友元，只需要在类中函数前加一个 friend 关键字来声明函数即可，并且访问性不受限制。

即表现形式为：

1. friend <返回类型> <函数名> (<参数列表>);

但这个友元函数他不属于该类的成员函数，他是定义在类外的普通函数，只是在类中声明该函数可以直接访问类中的 private 或者 protected 成员。

例如：

1. class Test{
2. private:
3. int a;
4. protected:
5. int b;
6. public:
7. friend void fun(Test t); // 友元函数
8. };
10. void fun(Test t)
11. {
12. t.a = 100;
13. t.b = 2000;
14. cout << "a = " << t.a << ", b = " << t.b << endl;
15. }
17. int main()
18. {
19. Test test;
20. fun(test);
21. return 0;
22. }

输出结果为：a = 100, b = 2000

友元类

C++ 中也允许声明一个类为某个类的友元类，方法和声明友元函数旗鼓相当。

但是需要注意的是，作为友元的类的声明必须在友元类的声明之前。

例如：

1. class TestFriend
2. {
3. private:
4. int a;
5. }; // TestFriend 类的声明在 Test 类之前
7. class Test
8. {
9. private:
10. int a;
11. friend class TestFriend; // 声明友元类
12. };

有时候作为友元的类的声明不便放在友元声明之前，这个时候就可以使用前置声明。

不过前置声明的类只是一个名字（或者说不完全类型），不能访问它内部的内容。

例如：

1. class TestFriend; // 前置声明 TestFriend 类，只是一个名字
3. class Test
4. {
5. private:
6. int a;
7. friend class TestFriend; // 声明友元类
9. friend void TestFriend::Func(); // 尝试将 TestFriend 类的成员函数 Func 作为友元函数，但由于 TestFriend 类目前只有前置声明，所以会出错。
   

   
   

10. };
12. class TestFriend // TestFriend 类的声明在 Test 类之后
13. {
14. private:
15. int a;
16. public:
17. void Func();
18. };

最后，友元声明还有如下限制：

• 友元关系不能被继承。
  

  
  

• 友元关系是单向的，不具有交换性。
  

  
  

  若类 B 是类 A 的友元，类 A 不一定是类 B 的友元。
  

  
  

• 友元关系不具有传递性。
  

  
  

  若类 B 是类 A 的友元，类 C 是 B 的友元，类 C 不一定是类 A 的友元。
  

  
  

转换构造函数

一个构造函数接收一个不同于其类类型的形参，可以视为将其形参转换成类的一个对象，像这样的构造函数称为转换构造函数。

因此转换构造函数的作用就是将一个其他类型的数据转换成一个类的对象。

除了创建类对象之外，转换构造函数还为编译器提供了执行隐式类型转换的方法。

只要在需要类的类型值的地方，给定构造函数的形参类型的值，就将由编译器执行这种类型的转换。

转换构造函数是构造函数的一个特例，当一个构造函数的参数只有一个，而且是一个其他类型的 const 引用时，它就是一个转换构造函数。

例如：

1. class T1{};
3. class T2
4. {
5. public:
6. T2(const T1 &t); // 从 T1 转换到 T2 的转换构造函数
7. };

有了转换构造函数，就可以实现不同类型之间的类型转换了，比如：

1. /* 类定义同上 */
2. int main()
3. {
4. T1 t1;
5. T2 t2= (T2)t1; // 用类型转换语法，从 T1 转换到 T2
6. T2 t3(t1); // 或者直接调用转换构造函数
7. }

注意：转换构造函数只能有一个参数。

如果有多个参数，就不是转换构造函数。

编程要求

在右侧编辑器中的Begin-End之间补充代码，设计学生和教师两个类，类中成员变量都为私有，成员函数都为公有，并实现它们之间的转换，具体要求如下：

1. 学生类（ Student ）

   • 编号：int number

   • 姓名：string name

   • 性别：string sex

   • 带参构造函数：Student(int num,string nam,string se)，用三个参数对应初始化内部的三个成员变量。
     

     
     

   • 输出函数：void Print()函数，输出学生信息，格式为：学生：name，编号：number，性别：sex。
     

     
     

1. 教师类（ Teacher ）

   • 与 Student 类有三个同样的成员变量

   • 输出函数：void Print()，输出教师信息，格式为：教师：name，编号：number，性别：sex的格式打印三个成员变量。
     

     
     

1. 转换构造函数，用于从 Student 类转换到 Teacher 类，它将 Student 对象的成员变量对应复制 Teacher 对象的成员变量中。
   

   
   

2. 头文件展示

3. #include 
   #include 
   using namespace std;
   
   // 前置声明 Teacher 类
   class Teacher;
   
   class Student{
       //声明友元对象
       friend Teacher;
       
   public:
       //构造函数
       Student(int number,string name,string sex) {
           m_number = number;
           m_name = name;
           m_sex = sex;
       }
   
       //打印函数
       void Print() {
           cout << "学生：" << m_name << "，编号：" << m_number 
           << "，性别：" << m_sex << endl;
       }
   
   //私有化成员变量
   private:    
       int m_number;
       string m_name;
       string m_sex;
   };
   
   class Teacher{
   public:
       //Print function
       void Print() {
           cout << "教师：" << m_name << "，编号：" << m_number 
           << "，性别：" << m_sex << endl;
       }
       
       //转换构造函数
       Teacher(const Student& st) {
           m_name = st.m_name;
           m_number = st.m_number;
           m_sex = st.m_sex;
       };
   
   //成员变量私有化
   private:
       int m_number;
       string m_name;
       string m_sex;
   };
   

   源文件展示

4. #include "usr.h"
   int main()
   {
   	int number;
   	string name,sex;
   	cin >> number >> name >> sex;
       Student st(number,name,sex);
       st.Print();
       Teacher t = (Teacher)st;
       t.Print();
   }