目录
简介:
友元:
全局函数做友元
类做友元
成员函数做友元
运算符重载
加号运算符重载
代码示例:
输入输出运算符重载
⭐cin
⭐cout
代码示例:
分析:
自增运算符重载
代码示例(成员函数实现):
分析:
==运算符重载
代码示例:
分析:
函数调用运算符()重载
代码示例:
以上的运算符完整重载代码:
总结:
简介:
介绍有关友元和运算符重载的知识,运算符重载根据介绍
友元:
1.类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。
⭐注意:友元函数并不是成员函数👉尽管友元函数的原型有在类的定义中出现了。
2.友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。
3.如果要声明函数为一个类的友元,需要在类定义中该函数原型前使用关键字 friend
全局函数做友元
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
//友元,有些私有的属性想要类外的某些函数或者是类来访问,就需要友元
//friend
//实现三种:全局函数做友元
class building {//建筑物类
friend void test(building& build);//实现全局函数可以访问私有成员了
public:
building() {
m_sittingroom = "客厅";
m_bedroom = "卧室";
}
public:
string m_sittingroom;
private:
string m_bedroom;
};
//引用或者指针传入
void test(building &build)//全局函数,可以访问私有成员
{
cout << "访问公共属性" << build.m_sittingroom<<endl;//运行成功
cout << "访问私有属性" << build.m_bedroom << endl;//加上类中的第一行代码之后就可以正常运行了
}
void test1() {
building build;
test(build);
}
int main()
{
test1();
system("pause");
return 0;
}
类做友元
#include<iostream>
#include<string>
using namespace std;
//友元,有些私有的属性想要类外的某些函数或者是类来访问,就需要友元
//friend为关键字
//实现:类做友元,类可以访问另一个类的私有属性
class building {//建筑物类
//good friend是本类的好朋友,
friend class goodfriend;
public:
building();
string m_sittingroom;
private:
string m_bedroom;
};
building::building() {//构造函数赋初值
m_sittingroom = "客厅";
m_bedroom = "卧室";
}
class goodfriend{//好朋友类
public:
goodfriend();
void visit();//在类外创建函数,则要在类内进行声明
building* build;
};
goodfriend::goodfriend() {//创建建筑物对象
build = new building;//在堆区创建
}
void goodfriend::visit()//参观函数,访问另一个类的属性
{
cout << "好朋友类访问公共属性" << build->m_sittingroom << endl;
cout << "好朋友类访问私有属性" << build->m_bedroom << endl;
}
void test1() {//测试案例代码
goodfriend f;//创建一个类对象后会先调用构造函数good friend(),这个函数里面有building另外一个类的对象创建,则调用building这个类的构造函数
f.visit();//使用类函数则要先创建类对象,然后调用类里的函数声明。
}
//类外写成员函数
int main()
{
test1();
system("pause");
return 0;
}
成员函数做友元
注意先声明building然后再定义朋友类,再定义建筑物类,再利用构造函数初始化朋友类,创建类对象,然后构造函数赋初值给类属性,重要的是,要先定义朋友类,再定义建筑类,不然程序会出错的。
#include<iostream>
#include<string>
using namespace std;
//友元,有些私有的属性想要类外的某些函数或者是类来访问,就需要友元
//friend为关键字
//实现:成员函数做友元
class building;
class goodfriend{//好朋友类
public:
goodfriend();
void visit1();//可以访问私有内容
void visit2();//只能访问公共内容
building* build;
};
class building {//建筑物类
//告诉编译器这个类下面的visit1函数作为本类的好朋友,可以访问私有内容
friend void goodfriend::visit1();
public:
building();
string m_sittingroom;
private:
string m_bedroom;
};
goodfriend::goodfriend() {//创建建筑物对象
build = new building;//在堆区创建
}
building::building() {//构造函数赋初值
m_sittingroom = "客厅";
m_bedroom = "卧室";
}
void goodfriend::visit1() {
cout << "访问类的公共属性:" << build->m_sittingroom << endl;
cout << "访问私有属性:" <<build->m_bedroom<< endl;
}
void goodfriend::visit2() {
cout << "访问类的公共属性:" << build->m_sittingroom << endl;
}
void test1() {//测试案例代码
goodfriend f;//创建一个类对象后会先调用构造函数good friend(),这个函数里面有building另外一个类的对象创建,则调用building这个类的构造函数
f.visit1();
f.visit2();
}
//类外写成员函数
int main()
{
test1();
system("pause");
return 0;
}
运算符重载
对于内置的数据类型,编译器知道如何运算。
而c++中有自定义数据类型,程序往往不知道如何去计算自定义数据类型
因此需要自己进行运算符重载,使用关键字operate
加号运算符重载
先新建一个自定义数据类型——类,然后对于类对象的直接相加计算机不知道如何计算——》需要进行加号运算符重载
代码示例:
这个是使用成员函数重载的+号运算符
由于是两个类对象直接相加,所以这里新建一个类对象让成员分别相加,最后返回person类型,这里的this指针是指向调用这个函数的类对象例如式子为p1+p2,则p1调用这个函数,并传入p2。
//成员函数重载+运算符 person operator+(person &p) { person t; t.m_age = this->m_age + p.m_age; t.m_high = this->m_high + p.m_high; return t; }
全局函数重载+运算符,这里是把两个类对象直接传入,不用this指针了。
//全局函数重载+运算符 person operator+(person p1, person p2) { person t; t.m_age = p1.m_age + p2.m_age; t.m_high = p1.m_high + p2.m_high; return t; }
输入输出运算符重载
这里需要知道两个流,在c++中cin和cout是输入输出最基本的符号
⭐cin
cin的类型是istream也就是说cin是一个istream类型的对象
⭐cout
cout类型为ostream,不是函数
⭐istream和ostream是iostream库中最常用的两个基础类型,本别为输入流和输出流(流为字符序列,主要操作对象为IO)
🆗基本知识了解后我们就可以写运算符重载函数了
代码示例:
分析:
首先对于<<运算符重载,第一先判定需要完成的功能——输出类对象的所有成员
由上图可知,参数1为cout,参数2为输出对象——类对象p
而返回值是怎么定的呢?由于会存在链式输出,当一个<<完成后返回值如果是类则无法输出如下图:
则>>运算符重载同理,也是先判断要完成的功能和参数,然后根据实际案例,确定返回值,即可完成运算符重载。
//重载<<运算符 ostream& operator<<(ostream&cout,const person& p) { cout << p.m_age<<" "; cout << p.m_high <<endl ; return cout; } //重载>>运算符 istream& operator>>(istream& cin, person& p)//这里不和重载<<运算符一样,不要加const { cin >> p.m_age; cin >> p.m_high; return cin; }
自增运算符重载
自增运算符分为两种——++a,a++
代码示例(成员函数实现):
分析:
首先我们要完成的是前缀的自增运算符,完成功能是要先把所有类对象的成员+1然后返回所有成员加一后的类对象
而后缀是需要先返回值再加值,而这一个不能先写return再加一,无法操作,那么这里可以借助新建一个类对象来对过去的数据进行存储,返回这个旧数据,而把调用这个函数的类对象的成员值增加1
为了区分两个自增运算符重载,对于后缀的参数里加(int),前缀的无参数
//重载后缀的自增运算符
person operator++(int)
{
person t;
t.m_age = this->m_age++;
t.m_high = this->m_high++;
return t;
}
//重载前缀的自增运算符
person operator++()
{
++this->m_age;
++this->m_high;
return *this;
}
==运算符重载
代码示例:
分析:
这里要实现的功能是判断两个类对象是否相等,参数是判断两个关系的类对象,返回值为布尔类型,在运算符重载函数中需要写if语句,通过判断两个的成员是否相等来判断两个类对象是否相等
//重载==关系运算符
bool operator==(person p1,person p2)
{
if (p1.m_age == p2.m_age&& p1.m_high == p2.m_high)
{
return 1;
}else
{
return 0;
}
}
函数调用运算符()重载
代码示例:
这里示例是要实现调用的类对象加上传进去的两个整型数据,然后返回。
//函数调用重载
person operator()(int a,int b)
{
this->m_age = this->m_age +a;
this->m_high = this->m_high +b;
return *this;
}
以上的运算符完整重载代码:
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<fstream>
using namespace std;
class person
{
public:
int m_age;
int m_high;
//成员函数重载+运算符
//person operator+(person &p)
//{
// person t;
// t.m_age = this->m_age + p.m_age;
// t.m_high = this->m_high + p.m_high;
// return t;
//}
//重载后缀的自增运算符
person operator++(int)
{
person t;
t.m_age = this->m_age++;
t.m_high = this->m_high++;
return t;
}
//重载前缀的自增运算符
person operator++()
{
++this->m_age;
++this->m_high;
return *this;
}
//函数调用重载
person operator()(int a,int b)
{
this->m_age = this->m_age +a;
this->m_high = this->m_high +b;
return *this;
}
};
//全局函数重载+运算符
person operator+(person p1, person p2)
{
person t;
t.m_age = p1.m_age + p2.m_age;
t.m_high = p1.m_high + p2.m_high;
return t;
}
//重载关系运算符
bool operator==(person p1,person p2)
{
if (p1.m_age == p2.m_age&& p1.m_high == p2.m_high)
{
return 1;
}
}
//重载<<运算符
ostream& operator<<(ostream&cout,const person& p)
{
cout << p.m_age<<" ";
cout << p.m_high <<endl ;
return cout;
}
//重载>>运算符
istream& operator>>(istream& cin, person& p)//这里不和重载<<运算符一样,不要加const
{
cin >> p.m_age;
cin >> p.m_high;
return cin;
}
void test1() {
person p1;
person p2;
person p3;
p1.m_age = 12;
p1.m_high = 153;
p2.m_age = 18;
p2.m_high = 192;
cout<<p1 + p2;
cout << p1++;//12 153
cout << p1;//13 154
cout << ++p2;//19 193
cin >> p3;//19 193
if (p2 == p3) {
cout << "你们身高和年龄一样啊" << endl;
}
person p4 = p3(10, 20);//29 213
cout << p4;//29 213
}
int main()
{
test1();
system("pause");
return 0;
}
总结:
对于c++的友元以及运算符重载就介绍到这里,欢迎点赞收藏文章和专栏(会分享更多代码知识),文章如有错误,请大佬指出,谢谢(●'◡'●)