6、C++中的友元与运算符重载

一、C++中的友元

1、C++中的访问权限

class base
{
	public: //共有成员,类内,子类,类外,都可以访问
		int a;
	protected: //保护成员,类内,子类可以访问
		int b;
	private: //私有成员,类内可以访问
		int c;
};

2、友元

  • 作用:用于访问类中的所有成员
  • 缺点:会破坏类的封装性,所以不要随便用友元

3、友元函数

语法:

friend 函数的返回值类型 函数名 (参数列表)
---------------------------------------
例子:
friend void show()//该函数就可以访问类中的所有成员
{
	
}
  • 1、当一个函数被声明为友元函数时,该函数就不属于类中的成员函数
  • 2、友元函数必须要在类内声明
  • 3、友元函数可以在类内任意位置声明,与成员权限无关

6、C++中的友元与运算符重载_第1张图片
例子:

#include 
using namespace std;

class base
{
    public:
        int a;
    protected:
        int b;
    private:
        int c;
    
    friend void show();
};

//base类的友元函数
void show()
{
    base a;
    a.a = 100;
    a.b = 200;
    a.c = 300;

    cout << a.a << endl;
    cout << a.b << endl;
    cout << a.c << endl;
}

int main()
{
    show();
}

4、友元函数可以继承吗

class base
{
	private:
		int a;
	//声明一个 set 友元函数
	friend void set();
};

class new_base:public base
{
	private:
		int b;
	//声明一个 set 友元函数
	//friend void set();假设不重新声明友元函数就不能访问私有成员
};
void set()
{
	base a;
	a.a = 1000; //可以访问私有 成员
	cout << a.a << endl;
	new_base b;
	b.b = 2000; //不可以访问 new_base 的私有成员。
}
  • 1、友元函数是不可以继承的
  • 2、假设需要友元函数可以访问子类的私有成员,则需要在子类中再次声明该函数为友元函数
  • 3、多个类可以对应一个友元函数
  • 4、一个类可以对应多个友元函数

二、友元类

作用:

  • 当一个类为另一个类的友类时,则该类可以访问对方的所有数据成员

语法:

friend class 类名
----------------
例子:
friend class base;

6、C++中的友元与运算符重载_第2张图片
练习: 让两个类互为友元。

#include 
using namespace std;

class base2;

class base1
{
    public:
        void set_b2();
        int a;
    protected:
        int b;
    private:
        int c;

    friend class base2;
};

class base2
{
    public:
        void set_b1()
        {
            base1 b1;
            b1.a = 10;
            b1.b = 20;
            b1.c = 30;
        }
        int a;
    protected:
        int b;
    private:
        int c;

    friend class base1;
};

//在base 定义后 才实现 set_base接口
void base1 :: set_b2()
{
    base2 b2;
    b2.a = 30;
    b2.b = 20;
    b2.c = 10;
}

int main()
{

}

三、运算符重载

1、作用:

  • 给已知的运算符赋予新的功能。比如:两个字符串的相加 , 两个类的相加,两个结构体的相加等。

语法:

返回类型 operator 运算符号 (参数列表)
------------------------------------
例子:重载两个类相加
base operator+(base a)
{
	
}

2、可重载运算符:

哪些运算能重载
双目运算符 (+,-,,/, %) operator+
关系运算符 (==, !=, <, >, <=, >=)
逻辑运算符 (||, &&, !)
单目运算符 (
, &, ++, --)
位运算符 (|, &, ~, ^, <<, >>)
赋值运算符 (=, +=, -=, …)
空间申请运算符 (new , delete)
其他运算符 ((), ->, [])

3、不可重载运算符:

哪些运算符不能重载
.(成员访问运算符)
.*(成员指针访问运算符)
::(域运算符)
sizeof(数据类型长度运算符)
?:(条件运算符, 三目运算符)

4、运算符重载的两种方式

类内重载方式:
	base operator+(参数列表)
调用规律:
	base c = a + b;  - > a.operator+(b)//两者等价
特点:
	a是调用者,b是参数。
	在类的内部重载,友this指针
类外重载方式:
	base operator+(base a, base b)
调用规律:
	base c = a + b;   ->    operator+(a, b)//两者等价
特点:
	a和b都是operator的参数,可以不用this指针

总结:

  • 这两种重载运算符的方式都是一样的,用户根据自己的需要选择

四、不同运算符重载的方式

1、关系运算符:

#include 
using namespace std;

class base 
{
    public:
        base(int a) : a(a){}

    private:
        int a;

    friend bool operator>(base a, base b);
};

//内外重载
bool operator>(base a, base b)
{
    if(a.a > b.a)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int main()
{
    base b1(10);
    base b2(100);

    if(b1 > b2)
    {
        cout << "b1 > b2" << endl;
    }
    else
    {
        cout << "b1 < b2" << endl;
    }
}

2、逻辑运算符

#include 
using namespace std;


class base
{
    public:
        base(int a) : a(a){}

        bool operator&&(base a)
        {
            if(this->a && a.a)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    private:
        int a;
};

int main()
{
    base a(100);
    base b(10);

    if(a&&b)
    {
        cout << "true" << endl;
    }
    else
    {
        cout << "false" << endl;
    }
}

3、单目运算符

#include 
using namespace std;

class base
{
    public:
        int a;
    base(int a) : a(a){}
    //++a 先自加,再用值
    base operator++()
    {
        cout << "调用++a" << endl; 
        this->a++;
        return *this;
    }

    //a++ 先用值,再自加
    base operator++(int)
    {
        cout << "调用a++" << endl;
        base tmp=*this; //保存原来的值
        this->a++;
        return tmp; //先返回值
    }
};

int main()
{
    base a(10);
    base b = a++;
    cout << a.a << endl;
    cout << b.a << endl;
}

利用位运算符 << , >>实现输入输出的重载

1、输出运算符的重载

#include 
#include 

using namespace std;

class base
{
    public:
        base(int a) : a(a){}

    private:
        int a;
    
    friend ostream &operator<<(ostream &out, base a);
};

//内外重载
ostream &operator<<(ostream &out, base a)
{
    cout << a.a;

    return out;
}

int main()
{
    base a(10086);
    base b(10010);

    cout << a << b << endl;
}

2、输入运算符的重载

#include 
#include 
using namespace std;


class base
{
    public:
        int a;
        base(){}
        base(int a) : a(a){}
};

istream & operator>>(istream &in,base &a)
{
    cin >> a.a;
    return in;
}

int main()
{
    base a;
    base b;

    cin >> a >> b;

    cout << a.a << endl;
    cout << b.a << endl;
}

五、字符串类的使用

6、C++中的友元与运算符重载_第3张图片
所有的字符串操作都可以使用string类去处理

构造函数

// 默认构造函数,创建一个空字符串
string();

// 构造函数,以指定字符重复构造字符串
string(size_type length, char ch);

// 构造函数,以C风格字符串创建字符串
string(const char *str);

// 构造函数,从C风格字符串中指定位置和长度创建字符串
string(const char *str, size_type length);

// 构造函数,从另一个字符串截取子串
string(string &str, size_type index, size_type length);

string 重载后的运算符:

6、C++中的友元与运算符重载_第4张图片

你可能感兴趣的:(C++的应用,c++,开发语言)