类（初学）（5）

逃离我推掉我的手 2023-06-24 15:24 2阅读 0赞

# 警告：本文是用来学习有关类的知识点，由于初学，所以必会犯很多错误，请大家酌情观看 #

**1、重载<<操作符**  
先移步至博客： [类（运算符重载）实现有理数的加减乘除][Link 1] 大致看一下 print（）函数 和 main（）函数 的内容

以 main()函数 的有理数加法运算 举例（下面是原代码）:
    
    Rational f1(2,16);
    Rational f2(7,8);
    Rational res = f1 + f2;
    f1.print();
    std::cout <<" + ";
    f2.print();
    std::cout <<" = ";
    res.print();
    std::cout <<"\n";
    
    可以看出要连续调用三次 print()函数，非常的繁琐

我们试着给 “<<” 重载看看

首先在 Rational类 中加入友元函数:
    friend std::ostream& operator<<(std::ostream& os,Rational f);
    
    并为其定义:
    friend std::ostream& operator<<(std::ostream& os,Rational f)
    { 
    	os<< f.fz <<"/"<< f.fm ;
    	return os
    }
    
    最后可以这样写输出表达式:
    std::cout<< f1 << "+" << f2 << "=" << (f1/f2) <<"\n";

**2、多继承**  
很好理解，举个例子就知道了

#include <iostream>
    #include <string>
    class Teacher
    { 
    	public:
    		Teacher(std::string Name1);
    		std::string a;
    };
    class Student
    { 
    	public:
    		Student(std::string Name2);
    		std::string b;
    };
    class Teachingstudent :public Student,public Teacher
    { 
    	public:
    		Teachingstudent(std::string Name3,std::string Name4);
    		void introduce();
    		std::string c;
    		std::string d;
    };
    
    Teacher::Teacher(std::string Name1)
    { 
    	a = Name1;
    }
    
    Student::Student(std::string Name2)
    { 
    	b = Name2;
    }
    
    Teachingstudent::Teachingstudent(std::string Name1,std::string Name2):Teacher(Name1),Student(Name2) //标记
    { 
    	c = Name1;
    	d = Name2;
    }
    int main()
    { 
    	Teachingstudent teachingstudent("1","2");
    	std::cout<<teachingstudent.a<<teachingstudent.b<<teachingstudent.c<<teachingstudent.d;
    	return 0;
    }

output:
    1212

当标记处 `Teacher(Name1),Student(Name2)` 变成 `Teacher(Name2),Student(Name1)` 时，最终会输出 2112，**原理是标记处 各个函数间 的参数是"相通的"**

**3、虚继承**  
虚继承主要解决多继承中出现变量访问不明确的问题，如：

#include <iostream>
    using namespace std;
    class A
    { 
    public:
    	A();
    	int num;
    };
    class B:virtual public A //虚继承（继承了 num）
    { 
    public: 
    	B();
    }; 
    class C:virtual public A //虚继承 （继承了 num）
    { 
    public: 
    	C();
    };
    class D:public B,public C
    { 
    public: 
    	D();
    };
    A::A()
    { 
    	num = 520;
    	cout<<"A"<<endl;
    }
    B::B()
    { 
    	cout<<"B"<<endl;
    }
    C::C()
    { 
    	cout<<"C"<<endl;
    }
    D::D()
    { 
    	cout<<"D"<<endl;
    }
    int main()
    { 
    	D d;
    	//cout<<d.num<<endl;//error:访问不明确；没加virtual前
    	//第一种方案：清楚的表明作用域，以免出现歧义
    	//cout<<d.B::num<<endl
    	//cout<<d.C::num<<endl
    	//第二种方案：加上virtual后，就没有歧义了，B和C都指向同一份A
    	cout<<d.num<<endl;//加上virtual OK
    	return 0;
    }

output:
    A
    B
    C
    D
    520

### 现阶段学的特别难，不仅在于类，还有OOJ（面向对象编程）很抽象，对于基本的语法也不能理解是为什么，所以等有足够能力了再继续更新吧( ᖛ ̫ ᖛ )ʃ) ###

[Link 1]: https://blog.csdn.net/CourserLi/article/details/103664198