c++基础总结(3)友元函数&运算符重载

1、C++友元

①友元函数：

[1]概念及语法：

指某些虽然不是类的成员却能够访问类的所有成员的函数；

为什么要使用：为了使其他类的成员函数来访问该类的私有变量

什么时候使用：可以用于运算符重载、两个类共享数据

调用方式：不是类的成员函数，调用时不通过对象

存在位置：可以在类内声明，类外定义，可放在类的私有段或公有段，放在私有段和公有段无区别。

举例：友元函数定义需要用到关键字 friend，

#include <iostream>
using namespace std;
class A{
    public:
         friend void set_show(int x, A &a);      //该函数是友元函数的声明
    private:
        int data;
};
void set_show(int x, A &a) {  //友元函数定义，为了访问类A中的成员
    a.data = x;
    cout << a.data << endl;
}
int main(void){
    class A a;
    set_show(1, a);
    return 0;
}

②友元类

友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）

关于友元类的注意事项：

(1) 友元关系不能被继承。

(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。

(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。

#include <iostream>
using namespace std;
class A{
    public:
          friend class C;       //这是友元类的声明
    private:
          int data;
};
class C {   //友元类定义，为了访问类A中的成员
    public:
       void set_show(int x, A &a) { a.data = x; cout<<a.data<<endl;}
};

int main(void){
    class A a;
    class C c;
    c.set_show(1, a);
    return 0;
}

③友元成员函数

使类B中的成员函数成为类A的友元函数，这样类B的该成员函数就可以访问类A的所有成员了。

#include <iostream>
using namespace std;
class A;    //当用到友元成员函数时，需注意友元声明与友元定义之间的互相依赖。这是类A的声明
class B{
    public:
          void set_show(int x, A &a);   //该函数是类A的友元函数
};
class A{
    public:
       friend void B::set_show(int x, A &a);   //该函数是友元成员函数的声明
    private:
       int data;
       void show() { cout << data << endl; }
};
void B::set_show(int x, A &a) {//只有在定义类A后才能定义该函数
    a.data = x;
    cout << a.data << endl;
}
int main(void){
    class A a;
    class B b;
    b.set_show(1, a);
    return 0;
}

2、类的静态成员

[1].静态成员变量

//定义静态数据成员
class Time{
    public :
        void showtime();
    private:
        static int hour; //定义hour为静态数据成员
        int minute;
        int sec;
};

//类的静态成员的初始化
int Time::hour=5;
//输出/调用静态成员
cout << "Total objects: " <<TIme::hour << endl;

[2].静态成员函数

class Box {
   public:
      static int objectCount;
      static int getCount() {
         return objectCount;
      }
};

// 初始化类 Box 的静态成员
int Box::objectCount = 0;
Box::getCount()//调用静态函数

3、C++中的重载：

 

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

[1].c++中的函数重载：

函数名称相同，参数列表不同。（这个跟java,php等相同）

 

[2].c++中运算符重载（c++特有）：

   i.函数名由operator关键字和重载运算符符号修饰。

   ii.与其他函数一样拥有参数列表和返回值类型。

  iii.运算符重载有两种方式：一种是类内重载（运算符重载函数作为类的成员函数），另一种是类外重载（运算符重载函数作为类的友元函数）

格式：

返回类型 operator 运算符名称(形参列表){

    重载实体;

}

C++支持重载的运算符

①-（负数）运算符重载（+正数类似）：

#include <iostream>
using namespace std;
class Complex{
public:
    Complex(float x=0, float y=0):_x(x),_y(y) {}
    void dis()
    {	
        cout<<"("<<_x<<","<<_y<<")"<<endl;
    }
    const Complex operator-() const
    {
        return Complex(-_x,-_y);
    }
private:
    float _x;
    float _y;
};
int main()
{
    int n = 10;
    //作对比
    cout<<"n = "<<n<<endl;
    cout<<"-n = "<<-n<<endl;
    cout<<"-(-n) = "<<-(-n)<<endl;
    //-n = 10;    error
    Complex c(1,2);
    c.dis();
    Complex c2 = -c;
    c2.dis();
    c2 = -(-c);
    c2.dis();
    return 0;
}

待续。。。