C++学习2（友元 重载 命名空间）

友元

友元函数

私有成员对于类外部的所有程序部分而言都是隐藏的，访问它们需要调用一个公共成员函数 。

在当前类以外定义的、不属于当前类的函数也可以在类中声明，但要在前面加 friend 关键字，这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。

一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 private 成员。

#include <iostream>
using namespace std;
class Date;
class Time{
public:
    Time(int,int,int);
    void display(Date &);
private:
    int hour;
    int minute;
    int sec;
};
class Date{
public:
    Date(int,int,int);
    friend void Time::display(Date &);
private:
    int month;
    int day;
    int year;
};
void Time::display(Date &d) {
    cout<<d.month<<"/"<<d.day<<"/"<<d.year<<endl;
    cout<<hour<<":"<<minute<<":"<<sec<<endl;
}
Time::Time(int h,int m,int s) :hour(h),minute(m),sec(s){}
Date::Date(int y,int m,int d):month(m),year(y),day(d){}
int main() {

    Time t1(10,13,56);
    Date d1(2021,12,25);
    t1.display(d1);
    return 0;
}

友元类

不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。 例如将类 B 声明为类 A 的友元类，那么类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有成员，包括 public、protected、private 属性的。

class Teacher;
class Student{
private:
    int score;
    char name;
    char id;
public:
    void display(Teacher &);
    Student(int s, char n, char i);

};
class Teacher{
private:
    int score;
    char name;
    char id;
public:
    friend class Student;
    Teacher(int s, char n, char i);

};
Teacher::Teacher(int s, char n, char i){
     score = s;
     name = n;
     id = i;

}
Student::Student(int s, char n, char i){
    score = s;
    name = n;
    id = i;
}
void Student::display(Teacher &d) {
    cout<<"score:"<<score<<endl;
    cout<<"teacher_score:"<<d.score<<endl;
}
int main(){
    Teacher t1(1,2,3);
    Student s1(4,5,6);
    s1.display(t1);
    return 0;
}

运算符重载

运算符函数是函数名由 operator 和 运算符 组合而成的函数，C++中的每一个运算符都对应着一个或多个这样的函数。具体实现时，操作数被转化为运算符函数的实参，系统会根据运算符及其实参的类型、个数、顺序等的不同，去调用相应的运算符函数，从而完成表达式的计算。

class complex
{
    private:
    double real,image;
    public:
    complex()
    {
        real = 0;
        image = 0;
    }
    complex(double r,double i)
    {
        real = r;
        image = i;
    }
    complex operator+(complex &op)
    {
        complex temp;
        temp.real = real + op.real;
        temp.image = image + op.image;
        return temp;
    }
};

void main()
{
    complex c1(1,2),c2(2,3);
    complex sum;
    
    sum = c1 + c2;
    
}

运算符重载函数

成员函数定义格式

//类内声明
函数类型 operator运算符（形参）;
//类外定义
函数类型 类域::operator运算符（形参）{}

友元函数重载运算符

//类内声明
friend 函数类型 operator运算符(形参);
//类外定义 函数名前不能加类域
函数类型 operator运算符(形参){};

C++命名空间

c++命名空间，也有叫名称空间。当随着项目的增大， 名称相互冲突的可能性也将增加。 使用多 个厂商的类库时， 可能导致名称冲突。 例如， 两个库可能都定义了名为 List、 Tree和Node的类， 但定义的方式不兼容。 用户可能希望使用一个 库的List类， 而使用另一个库的Tree类。 这种冲突被称为名称空间问题。

在不用的作用域中变量a会有什么不同。

例子：

#include "iostream"
#include "cstdio"
using namespace std;//1作用域在 全局
namespace examply1{
    //using namespace std;
    /*
     * 如果不想在全局使用，就需要
     * 在至指定作用域进行声明
     */
    int a=100;
    namespace examply0{//嵌套 命名空间
        int a=200;
        void print_a(){
                cout<<"a="<<a<<endl;
        }
    }
}
namespace examply2{
    int a=1000;
    namespace examply0{
        int a=2000;
        void print_a(){
                cout<<"a="<<a<<endl;
        }
    }
}
int a = 250;
int main(){
    int a = 1;
    printf("examply1::a :%d\n",examply1::a);
    printf("examply1::examply0::a :%d\n",examply1::examply0::a);
    printf("局部变量a=%d\n",a);
    printf("全局变量变量a=%d\n",::a);
    using namespace examply1;
    printf("加入一句using namespace examply1;\n");
    printf("局部变量a=%d 依旧不变\n",a);
    printf("examply2::a :%d\n",examply2::a);
    printf("examply2::examply0::a :%d\n",examply2::examply0::a);
    return 0;
}

运行结果：