C++基础知识（四）-友元和运算符重载整理码字不易，养成好习惯，点赞关注，你的支持就是我写下去的动力，谢谢老板。本文为C++第三篇后续接着这篇文章写，大家可以持续关注，前三篇在主页

class Building;

//友元类

class MyFriend{

public:

//友元成员函数

void LookAtBedRoom(Building& building);

void PlayInBedRoom(Building& building);

};

class Building{

//全局函数做友元函数

friend void CleanBedRoom(Building& building);

#if 0

//成员函数做友元函数

friend void MyFriend::LookAtBedRoom(Building& building);

friend void MyFriend::PlayInBedRoom(Building& building);

#else

//友元类

friend class MyFriend;

#endif

public:

Building();

public:

string mSittingRoom;

private:

string mBedroom;

};

void MyFriend::LookAtBedRoom(Building& building){

cout << "我的朋友参观" << building.mBedroom << endl;

}

void MyFriend::PlayInBedRoom(Building& building){

cout << "我的朋友玩耍在" << building.mBedroom << endl;

}

//友元全局函数

void CleanBedRoom(Building& building){

cout << "友元全局函数访问" << building.mBedroom << endl;

}

Building::Building(){

this->mSittingRoom = "客厅";

this->mBedroom = "卧室";

}

int main(){

Building building;

MyFriend myfriend;

CleanBedRoom(building);

myfriend.LookAtBedRoom(building);

myfriend.PlayInBedRoom(building);

system("pause");

return EXIT_SUCCESS;

}

    [友元类注意]

1. 友元关系不能被继承。
2. 友元关系是单向的，类A是类B的朋友，但类B不一定是类A的朋友。
3. 友元关系不具有传递性。类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。

如果一个类被声明为friend,意味着它不是这个类的成员函数，却可以修改这个类的私有成员，而且必须列在类的定义中，因此他是一个特权函数。c++不是完全的面向对象语言，而只是一个混合产品。增加friend关键字只是用来解决一些实际问题，这也说明这种语言是不纯的。毕竟c++设计的目的是为了实用性，而不是追求理想的抽象。

                                                       --- Thinking in C++

请编写电视机类，电视机有开机和关机状态，有音量，有频道，提供音量操作的方法，频道操作的方法。由于电视机只能逐一调整频道，不能指定频道，增加遥控类，遥控类除了拥有电视机已有的功能，再增加根据输入调台功能。

class Remote;

class Television{

friend class Remote;

public:

enum{ On,Off }; //电视状态

enum{ minVol,maxVol = 100 }; //音量从0到100

enum{ minChannel = 1,maxChannel = 255 }; //频道从1到255

Television(){

mState = Off;

mVolume = minVol;

mChannel = minChannel;

}

//打开电视机

void OnOrOff(){

this->mState = (this->mState == On ? Off : On);

}

//调高音量

void VolumeUp(){

if (this->mVolume >= maxVol){

return;

}

this->mVolume++;

}

//调低音量

void VolumeDown(){

if (this->mVolume <= minVol){

return;

}

this->mVolume--;

}

//更换电视频道

void ChannelUp(){

if (this->mChannel >= maxChannel){

return;

}

this->mChannel++;

}

void ChannelDown(){

if (this->mChannel <= minChannel){

return;

}

this->mChannel--;

}

//展示当前电视状态信息

void ShowTeleState(){

cout << "开机状态:" << (mState == On ? "已开机" : "已关机") << endl;

if (mState == On){

cout << "当前音量:" << mVolume << endl;

cout << "当前频道:" << mChannel << endl;

}

cout << "-------------" << endl;

}

private:

int mState; //电视状态，开机，还是关机

int mVolume; //电视机音量

int mChannel; //电视频道

};

//电视机调台只能一个一个的调，遥控可以指定频道

//电视遥控器

class Remote{

public:

Remote(Television* television){

pTelevision = television;

}

public:

void OnOrOff(){

pTelevision->OnOrOff();

}

//调高音量

void VolumeUp(){

pTelevision->VolumeUp();

}

//调低音量

void VolumeDown(){

pTelevision->VolumeDown();

}

//更换电视频道

void ChannelUp(){

pTelevision->ChannelUp();

}

void ChannelDown(){

pTelevision->ChannelDown();

}

//设置频道 遥控新增功能

void SetChannel(int channel){

if (channel < Television::minChannel || channel > Television::maxChannel){

return;

}

pTelevision->mChannel = channel;

}

//显示电视当前信息

void ShowTeleState(){

pTelevision->ShowTeleState();

}

private:

Television* pTelevision;

};

//直接操作电视

void test01(){

Television television;

television.ShowTeleState();

television.OnOrOff(); //开机

television.VolumeUp(); //增加音量+1

television.VolumeUp(); //增加音量+1

television.VolumeUp(); //增加音量+1

television.VolumeUp(); //增加音量+1

television.ChannelUp(); //频道+1

television.ChannelUp(); //频道+1

television.ShowTeleState();

}

//通过遥控操作电视

void test02(){

//创建电视

Television television;

//创建遥控

Remote remote(&television);

remote.OnOrOff();

remote.ChannelUp();//频道+1

remote.ChannelUp();//频道+1

remote.ChannelUp();//频道+1

remote.VolumeUp();//音量+1

remote.VolumeUp();//音量+1

remote.VolumeUp();//音量+1

remote.VolumeUp();//音量+1

remote.ShowTeleState();

}

#ifndef MYARRAY_H

#define MYARRAY_H

class MyArray{

public:

//无参构造函数，用户没有指定容量，则初始化为100

MyArray();

//有参构造函数，用户指定容量初始化

explicit MyArray(int capacity);

//用户操作接口

//根据位置添加元素

void SetData(int pos, int val);

//获得指定位置数据

int GetData(int pos);

//尾插法

void PushBack(int val);

//获得长度

int GetLength();

//析构函数，释放数组空间

~MyArray();

private:

int mCapacity; //数组一共可容纳多少个元素

int mSize; //当前有多少个元素

int* pAdress; //指向存储数据的空间

};

#endif

#include"MyArray.h"

MyArray::MyArray(){

this->mCapacity = 100;

this->mSize = 0;

//在堆开辟空间

this->pAdress = new int[this->mCapacity];

}

//有参构造函数，用户指定容量初始化

MyArray::MyArray(int capacity){

this->mCapacity = capacity;

this->mSize = 0;

//在堆开辟空间

this->pAdress = new int[capacity];

}

//根据位置添加元素

void MyArray::SetData(int pos, int val){

if (pos < 0 || pos > mCapacity - 1){

return;

}

pAdress[pos] = val;

}

//获得指定位置数据

int MyArray::GetData(int pos){

return pAdress[pos];

}

//尾插法

void MyArray::PushBack(int val){

if (mSize >= mCapacity){

return;

}

this->pAdress[mSize] = val;

this->mSize++;

}

//获得长度

int MyArray::GetLength(){

return this->mSize;

}

//析构函数，释放数组空间

MyArray::~MyArray(){

if (this->pAdress != nullptr){

delete[] this->pAdress;

}

}

#include"MyArray.h"

void test(){

//创建数组

MyArray myarray(50);

//数组中插入元素

for (int i = 0; i < 50; i++){

//尾插法

myarray.PushBack(i);

//myarray.SetData(i, i);

}

//打印数组中元素

for (int i = 0; i < myarray.GetLength(); i++){

cout << myarray.GetData(i) << " ";

}

cout << endl;

}

    运算符重载(operator overloading)只是一种”语法上的方便”,也就是它只是另一种函数调用的方式。

   定义重载的运算符就像定义函数，只是该函数的名字是operator@,这里的@代表了被重载的运算符。函数的参数中参数个数取决于两个因素。

1. 运算符是一元(一个参数)的还是二元(两个参数)；
2. 运算符被定义为全局函数(对于一元是一个参数，对于二元是两个参数)还是成员函数(对于一元没有参数，对于二元是一个参数-此时该类的对象用作左耳参数)

   [两个极端]

   有些人很容易滥用运算符重载。它确实是一个有趣的工具。但是应该注意，它仅仅是一种语法上的方便而已，是另外一种函数调用的方式。从这个角度来看，只有在能使涉及类的代码更易写，尤其是更易读时(请记住，读代码的机会比我们写代码多多了)才有理由重载运算符。如果不是这样，就改用其他更易用，更易读的方式。

   对于运算符重载，另外一个常见的反应是恐慌：突然之间，C运算符的含义变得不同寻常了，一切都变了，所有C代码的功能都要改变！并非如此，对于内置的数据类型的表示总的所有运算符是不可能改变的。

class Person{

friend ostream& operator<<(ostream& os, Person& person);

public:

Person(int id,int age){

mID = id;

mAge = age;

}

private:

int mID;

int mAge;

};

ostream& operator<<(ostream& os, Person& person){

os << "ID:" << person.mID << " Age:" << person.mAge;

return os;

}

int main(){

Person person(1001, 30);

//cout << person; //cout.operator+(person)

cout << person << " | " << endl;

return EXIT_SUCCESS;

}

class Complex{

friend ostream& operator<<(ostream& os,Complex& complex){

os << "A:" << complex.mA << " B:" << complex.mB << endl;

return os;

}

public:

Complex(){

mA = 0;

mB = 0;

}

//重载前置++

Complex& operator++(){

mA++;

mB++;

return *this;

}

//重载后置++

Complex operator++(int){

Complex temp;

temp.mA = this->mA;

temp.mB = this->mB;

mA++;

mB++;

return temp;

}

//前置--

Complex& operator--(){

mA--;

mB--;

return *this;

}

//后置--

Complex operator--(int){

Complex temp;

temp.mA = mA;

temp.mB = mB;

mA--;

mB--;

return temp;

}

void ShowComplex(){

cout << "A:" << mA << " B:" << mB << endl;

}

private:

int mA;

int mB;

};

void test(){

Complex complex;

complex++;

cout << complex;

++complex;

cout << complex;

Complex ret = complex++;

cout << ret;

cout << complex;

cout << "------" << endl;

ret--;

--ret;

cout << "ret:" << ret;

complex--;

--complex;

cout << "complex:" << complex;

}

优先使用++和--的标准形式，优先调用前置++。

如果定义了++c，也要定义c++，递增操作符比较麻烦，因为他们都有前缀和后缀形式，而两种语义略有不同。重载operator++和operator--时应该模仿他们对应的内置操作符。

对于++和--而言，后置形式是先返回，然后对象++或者--，返回的是对象的原值。前置形式，对象先++或--，返回当前对象，返回的是新对象。其标准形式为:

调用代码时候，要优先使用前缀形式，除非确实需要后缀形式返回的原值，前缀和后缀形式语义上是等价的，输入工作量也相当，只是效率经常会略高一些，由于前缀形式少创建了一个临时对象。

class Person{

public:

Person(int param){

this->mParam = param;

}

void PrintPerson(){

cout << "Param:" << mParam << endl;

}

private:

int mParam;

};

class SmartPointer{

public:

SmartPointer(Person* person){

this->pPerson = person;

}

//重载指针的->、*操作符

Person* operator->(){

return pPerson;

}

Person& operator*(){

return *pPerson;

}

~SmartPointer(){

if (pPerson != NULL){

delete pPerson;

}

}

public:

Person* pPerson;

};

void test01(){

//Person* person = new Person(100);

//如果忘记释放，那么就会造成内存泄漏

SmartPointer pointer(new Person(100));

pointer->PrintPerson();

}

class Person{

friend ostream& operator<<(ostream& os,const Person& person){

os << "ID:" << person.mID << " Age:" << person.mAge << endl;

return os;

}

public:

Person(int id,int age){

this->mID = id;

this->mAge = age;

}

//重载赋值运算符

Person& operator=(const Person& person){

this->mID = person.mID;

this->mAge = person.mAge;

return *this;

}

private:

int mID;

int mAge;

};

//1. =号混淆的地方

void test01(){

Person person1(10, 20);

Person person2 = person1; //调用拷贝构造

//如果一个对象还没有被创建，则必须初始化，也就是调用构造函数

//上述例子由于person2还没有初始化，所以会调用构造函数

//由于person2是从已有的person1来创建的，所以只有一个选择

//就是调用拷贝构造函数

person2 = person1; //调用operator=函数

//由于person2已经创建，不需要再调用构造函数，这时候调用的是重载的赋值运算符

}

//2. 赋值重载案例

void test02(){

Person person1(20, 20);

Person person2(30, 30);

cout << "person1:" << person1;

cout << "person2:" << person2;

person2 = person1;

cout << "person2:" << person2;

}

//常见错误，当准备给两个相同对象赋值时，应该首先检查一下这个对象是否对自身赋值了

//对于本例来讲，无论如何执行这些赋值运算都是无害的，但如果对类的实现进行修改，那么将会出现差异；

//3. 类中指针

class Person2{

friend ostream& operator<<(ostream& os, const Person2& person){

os << "Name:" << person.pName << " ID:" << person.mID << " Age:" << person.mAge << endl;

return os;

}

public:

Person2(char* name,int id, int age){

this->pName = new char[strlen(name) + 1];

strcpy(this->pName, name);

this->mID = id;

this->mAge = age;

}

#if 1

//重载赋值运算符

Person2& operator=(const Person2& person){

//注意:由于当前对象已经创建完毕，那么就有可能pName指向堆内存

//这个时候如果直接赋值，会导致内存没有及时释放

if (this->pName != NULL){

delete[] this->pName;

}

this->pName = new char[strlen(person.pName) + 1];

strcpy(this->pName,person.pName);

this->mID = person.mID;

this->mAge = person.mAge;

return *this;

}

#endif

//析构函数

~Person2(){

if (this->pName != NULL){

delete[] this->pName;

}

}

private:

char* pName;

int mID;

int mAge;

};

void test03(){

Person2 person1("John",20, 20);

Person2 person2("Edward",30, 30);

cout << "person1:" << person1;

cout << "person2:" << person2;

person2 = person1;

cout << "person2:" << person2;

}

    如果没有重载赋值运算符，编译器会自动创建默认的赋值运算符重载函数。行为类似默认拷贝构造，进行简单值拷贝。

class Complex{

public:

Complex(char* name,int id,int age){

this->pName = new char[strlen(name) + 1];

strcpy(this->pName, name);

this->mID = id;

this->mAge = age;

}

//重载==号操作符

bool operator==(const Complex& complex){

if (strcmp(this->pName,complex.pName) == 0 && 

    this->mID == complex.mID && 

this->mAge == complex.mAge){

return true;

}

return false;

}

//重载!=操作符

bool operator!=(const Complex& complex){

if (strcmp(this->pName, complex.pName) != 0 || 

    this->mID != complex.mID || 

this->mAge != complex.mAge){

return true;

}

return false;

}

~Complex(){

if (this->pName != NULL){

delete[] this->pName;

}

}

private:

char* pName;

int mID;

int mAge;

};

void test(){

Complex complex1("aaa", 10, 20);

Complex complex2("bbb", 10, 20);

if (complex1 == complex2){ cout << "相等!" << endl; }

if (complex1 != complex2){ cout << "不相等!" << endl; }

}

class Complex{

public:

int Add(int x,int y){

return x + y;

}

int operator()(int x,int y){

return x + y;

}

};

void test01(){

Complex complex;

cout << complex.Add(10,20) << endl;

//对象当做函数来调用

cout << complex(10, 20) << endl;

}

class Complex{

public:

Complex(int flag){

this->flag = flag;

}

Complex& operator+=(Complex& complex){

this->flag = this->flag + complex.flag;

return *this;

}

bool operator&&(Complex& complex){

return this->flag && complex.flag;

}

public:

int flag;

};

int main(){

Complex complex1(0);  //flag 0

Complex complex2(1);  //flag 1

//原来情况，应该从左往右运算，左边为假，则退出运算，结果为假

//这边却是，先运算（complex1+complex2），导致，complex1的flag变为complex1+complex2的值， complex1.a = 1

// 1 && 1

//complex1.operator&&(complex1.operator+=(complex2))

if (complex1 && (complex1 += complex2)){   

cout << "真!" << endl;

}

else{

cout << "假!" << endl;

}

return EXIT_SUCCESS;

}

#define _CRT_SECURE_NO_WARNINGS

#pragma once

#include <iostream>

using namespace std;

class MyString

{

friend ostream& operator<< (ostream  & out, MyString& str);

friend istream& operator>>(istream& in, MyString& str);

public:

MyString(const char *);

MyString(const MyString&);

~MyString();

char& operator[](int index); //[]重载

//=号重载

MyString& operator=(const char * str);

MyString& operator=(const MyString& str);

//字符串拼接 重载+号

MyString operator+(const char * str );

MyString operator+(const MyString& str);

//字符串比较

bool operator== (const char * str);

bool operator== (const MyString& str);

private:

char * pString; //指向堆区空间

int m_Size; //字符串长度 不算''

};

#include "MyString.h"

//左移运算符

ostream& operator<< (ostream & out, MyString& str)

{

out << str.pString;

return out;

}

//右移运算符

istream& operator>>(istream& in, MyString& str)

{

//先将原有的数据释放

if (str.pString != NULL)

{

delete[] str.pString;

str.pString = NULL;

}

char buf[1024]; //开辟临时的字符数组，保存用户输入内容

in >> buf;

str.pString = new char[strlen(buf) + 1];

strcpy(str.pString, buf);

str.m_Size = strlen(buf);

return in;

}

//构造函数

MyString::MyString(const char * str)

{

this->pString = new char[strlen(str) + 1];

strcpy(this->pString, str);

this->m_Size = strlen(str);

}

//拷贝构造

MyString::MyString(const MyString& str)

{

this->pString = new char[strlen(str.pString) + 1];

strcpy(this->pString, str.pString);

this->m_Size = str.m_Size;

}

//析构函数

MyString::~MyString()

{

if (this->pString!=NULL)

{

delete[]this->pString;

this->pString = NULL;

}

}

char& MyString::operator[](int index)

{

return this->pString[index];

}

MyString& MyString::operator=(const char * str)

{

if (this->pString != NULL){

delete[] this->pString;

this->pString = NULL;

}

this->pString = new char[strlen(str) + 1];

strcpy(this->pString, str);

this->m_Size = strlen(str);

return *this;

}

MyString& MyString::operator=(const MyString& str)

{

if (this->pString != NULL){

delete[] this->pString;

this->pString = NULL;

}

this->pString = new char[strlen(str.pString) + 1];

strcpy(this->pString, str.pString);

this->m_Size = str.m_Size;

return *this;

}

MyString MyString::operator+(const char * str)

{

int newsize = this->m_Size + strlen(str) + 1;

char *temp = new char[newsize];

memset(temp, 0, newsize);

strcat(temp, this->pString);

strcat(temp, str);

MyString newstring(temp);

delete[] temp;

return newstring;

}

MyString MyString::operator+(const MyString& str)

{

int newsize = this->m_Size + str.m_Size + 1;

char *temp = new char[newsize];

memset(temp, 0, newsize);

strcat(temp, this->pString);

strcat(temp, str.pString);

MyString newstring(temp);

delete[] temp;

return newstring;

}

bool MyString::operator==(const char * str)

{

if (strcmp(this->pString, str) == 0 && strlen(str) == this->m_Size){

return true;

}

return false;

}

bool MyString::operator==(const MyString& str)

{

if (strcmp(this->pString, str.pString) == 0 && str.m_Size == this->m_Size){

return true;

}

return false;

}

void test01()

{

MyString str("hello World");

cout << str << endl;

//cout << "请输入MyString类型字符串：" << endl;

//cin >> str;

//cout << "字符串为： " << str << endl;

//测试[]

cout << "MyString的第一个字符为：" << str[0] << endl;

//测试 =

MyString str2 = "^_^";

MyString str3 = "";

str3 = "aaaa";

str3 = str2;

cout << "str2 = " << str2 << endl;

cout << "str3 = " << str3 << endl;

//测试 +

MyString str4 = "我爱";

MyString str5 = "北京";

MyString str6 = str4 + str5;

MyString str7 = str6 + "天安门";

cout << str7 << endl;

//测试 ==

if (str6 == str7)

{

cout << "s6 与 s7相等" << endl;

}

else

{

cout << "s6 与 s7不相等" << endl;

}

}

优先级

运算符

名称或含义

使用形式

结合方向

说明

1

[]

数组下标

数组名[常量表达式]

左到右

--

()

圆括号

(表达式）/函数名(形参表)

--

.

成员选择（对象）

对象.成员名

--

->

成员选择（指针）

对象指针->成员名

--

2

-

负号运算符

-表达式

右到左

单目运算符

~

按位取反运算符

~表达式

++

自增运算符

++变量名/变量名++

--

自减运算符

--变量名/变量名--

*

取值运算符

*指针变量

&

取地址运算符

&变量名

!

逻辑非运算符

!表达式

(类型)

强制类型转换

(数据类型)表达式

--

sizeof

长度运算符

sizeof(表达式)

--

3

/

除

表达式/表达式

左到右

双目运算符

*

乘

表达式*表达式

%

余数（取模）

整型表达式%整型表达式

4

+

加

表达式+表达式

左到右

双目运算符

-

减

表达式-表达式

5

<<

左移

变量<<表达式

左到右

双目运算符

>>

右移

变量>>表达式

6

>

大于

表达式>表达式

左到右

双目运算符

>=

大于等于

表达式>=表达式

<

小于

表达式<表达式

<=

小于等于

表达式<=表达式

7

==

等于

表达式==表达式

左到右

双目运算符

！=

不等于

表达式!= 表达式

8

&

按位与

表达式&表达式

左到右

双目运算符

9

^

按位异或

表达式^表达式

左到右

双目运算符

10

|

按位或

表达式|表达式

左到右

双目运算符

11

&&

逻辑与

表达式&&表达式

左到右

双目运算符

12

||

逻辑或

表达式||表达式

左到右

双目运算符

13

?:

条件运算符

表达式1?

表达式2: 表达式3

右到左

三目运算符

14

=

赋值运算符

变量=表达式

右到左

--

/=

除后赋值

变量/=表达式

--

*=

乘后赋值

变量*=表达式

--

%=

取模后赋值

变量%=表达式

--

+=

加后赋值

变量+=表达式

--

-=

减后赋值

变量-=表达式

--

<<=

左移后赋值

变量<<=表达式

--

>>=

右移后赋值

变量>>=表达式

--

&=

按位与后赋值

变量&=表达式

--

^=

按位异或后赋值

变量^=表达式

--

|=

按位或后赋值

变量|=表达式

--

15

，

逗号运算符

表达式,表达式,…

左到右

--