C++学习记录2
练习模板：
点击查看代码
#include<iostream>
using namespace std;
int main()
{
system("pause");
return 0;
}
代码1：全局函数做友元
点击查看代码
#include<iostream>
using namespace std;
//友元：让一个函数或者类 访问另一个类当中的私有成员
//friend
//全局函数做友元 类做友元 成员函数做友元
class Building
{
//表明这个全局函数是我这个类的好朋友 可以访问这个类当中的私有成员
friend void goodGay(Building* building);
public:
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//全局函数
void goodGay(Building * building)
{
cout << "正在访问 ：" << building->m_SittingRoom << endl;
cout << "可以访问：" << building->m_BedRoom << endl;//好朋友
}
//
void test01()
{
Building b;
goodGay(&b);
}
int main()
{
test01();
return 0;
}
代码2：类做友元
点击查看代码
//类做友元：让一个类可以访问另一个类当中的私有成员
#include<iostream>
using namespace std;
//#include<string>
class Building;
class Building
{
friend class GoodGay;
//GoodGay类是本类的好朋友 可以访问本类的私有成员
public:
Building();
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
class GoodGay
{
public:
GoodGay();
void visit();//访问Building里面的属性
Building* building;
};
GoodGay::GoodGay()
{
//创建建筑物对象
building = new Building;
}
void GoodGay::visit()
{
cout << "正在访问：" << building->m_SittingRoom << endl;
cout << "正在访问：" << building->m_BedRoom<< endl;
}
//类外去写成员函数
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
void test01()
{
GoodGay g;
g.visit();
}
int main()
{
test01();
return 0;
}
代码3：成员函数做友元
//!!!Building类会先去介绍自己的好朋友 所以说GoodGay在Building之前定义
点击查看代码
#include<iostream>
using namespace std;
//#include<string>
class Building;
class GoodGay
{
public:
GoodGay();
void visit();//访问Building里面的属性
Building* building;
};
//!!!Building类会先去介绍自己的好朋友 所以说GoodGay在Building之前定义
class Building
{
//GoodGay类下的visit函数作为本类的好朋友 可以访问私有的成员
friend void GoodGay::visit();
public:
Building();
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
Building::Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
//创建建筑物对象
building = new Building;
}
void GoodGay::visit()
{
cout << "正在访问：" << building->m_SittingRoom << endl;
cout << "正在访问：" << building->m_BedRoom << endl;
}
//类外去写成员函数
void test01()
{
GoodGay g;
g.visit();
}
int main()
{
test01();
return 0;
}
代码4：加号运算符重载
//对于内置的数据类型的表达式的运算符是不可能发生改变的
点击查看代码
#include<iostream>
using namespace std;
//加号运算符重载
class Person
{
public:
//通过成员函数来实现加号重载
Person operator+(Person& p)
{
Person t;
t.m_A = this->m_A + p.m_A;
t.m_B = this->m_B + p.m_B;
return t;
}
int m_A;
int m_B;
};
//通过全局函数来实现加号重载
//Person operator+(Person &p1,Person &p2)
//{
// Person t;
// t.m_A = p1.m_A + p2.m_A;
// t.m_B = p2.m_B + p2.m_B;
// return t;
//}
//实现函数重载
Person operator+(Person& p1, int num)
{
//如果要把operator在类当中声明或者定义 那么就只可以有一个参数
Person t;
t.m_A = p1.m_A + num;
t.m_B = p1.m_B + num;
return t;
}
void test01()
{
Person p1;
p1.m_A = 10;
p1.m_B = 10;
Person p2;
p2.m_A = 10;
p2.m_B = 10;
//成员函数本质的调用
//Person p3 = p1.operator+(p2);
//全局函数本质的调用
//Person p3 = operator+(p1, p2);
//以上可以简化为
//Person p3 = p1 + p2;
//cout << p3.m_A << endl;
//cout << p3.m_B << endl;
//运算符重载 也可以发生函数重载
Person p3 = p1 + 181;
cout << p3.m_A << endl;
cout << p3.m_B << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
后面部分为C++运算符重载：
第一部分使用成员函数来实现
加号运算符重载
代码如下：
点击查看代码
#include<iostream>
using namespace std;
//运算符重载：对于已经有的运算符重新进行定义 赋予其另一种功能 以适应不同的数据类型
//加法：
//1通过成员函数 2通过全局函数
//1
class Person
{
public:
//成员函数
Person operator+(Person& p1)
{
Person pdome;
pdome.m_A = this->m_A + p1.m_A;
pdome.m_B = this->m_B + p1.m_B;
return pdome;
}
int m_A;
int m_B;
};
void test01()
{
Person p1;
p1.m_A = 1;
p1.m_B = 1;
Person p2;
p2.m_A = 1;
p2.m_B = 1;
Person p3 = p1 + p2;
cout << "-------" << p3.m_A << " + " << p3.m_B << "-------" << endl;
}
int main()
{
test01();
//实现
system("pause");
return 0;
}
第二部分使用全局函数来实现
加号运算符重载
代码如下：
点击查看代码
#include<iostream>
using namespace std;
//运算符重载：对于已经有的运算符重新进行定义 赋予其另一种功能 以适应不同的数据类型
//加法：
//1通过成员函数 2通过全局函数
class Person
{
public:
int m_A;
int m_B;
};
//2
Person operator+(Person& p1, Person& p2)
{
Person ptest;
ptest.m_A = p1.m_A + p2.m_A;
ptest.m_B = p1.m_B + p2.m_B;
return ptest;
}
void test01()
{
Person p1;
p1.m_A = 1;
p1.m_B = 1;
Person p2;
p2.m_A = 1;
p2.m_B = 1;
Person p3 = p1 + p2;
cout << "-------" << p3.m_A << " + " << p3.m_B << "-------" << endl;
}
int main()
{
test01();
//实现
system("pause");
return 0;
}
成员函数重载本质的调用：
Person p3 = p1.operator+(p2)；
//等价于：Person p3 = p1 + p2；
全局函数重载本质的调用：
Person p3 = operator+(p1,p2)；
//等价于：Person p3 = p1 + p2；
运算符重载也可以发生函数重载：
代码如下：
点击查看代码
#include<iostream>
using namespace std;
//运算符重载：对于已经有的运算符重新进行定义 赋予其另一种功能 以适应不同的数据类型
//加法：
//1通过成员函数 2通过全局函数
class Person
{
public:
int m_A;
int m_B;
};
//3
Person operator+(Person& p1, Person& p2)
{
Person ptest;
ptest.m_A = p1.m_A + p2.m_A;
ptest.m_B = p1.m_B + p2.m_B;
return ptest;
}
Person operator+(Person& p1,int num)
{
Person ptest;
ptest.m_A = p1.m_A + num;
ptest.m_B = p1.m_B + num;
return ptest;
}
void test01()
{
Person p1;
p1.m_A = 1;
p1.m_B = 1;
Person p2;
p2.m_A = 1;
p2.m_B = 1;
Person p3 = p1 + p2;
Person p4 = p3 + 1;
//Person + int
cout << "-------" << p4.m_A << " + " << p4.m_B << "-------" << endl;
//cout << "-------" << p3.m_A << " + " << p3.m_B << "-------" << endl;
}
int main()
{
test01();
//实现
system("pause");
return 0;
}
只能使用全局函数来重载左移运算符
第三部分使用全局函数来实现
左移运算符重载
代码如下：
点击查看代码
//左移运算符重载
#include<iostream>
using namespace std;
//可以输出自定义的数据类型“<<”
class Person
{
public:
int m_A;
int m_B;
};
//1
//void operator<<(ostream &cout,Person &p)
//{
// cout << p.m_A << "-------" << p.m_B << endl;
//}
//2
ostream& operator<<(ostream &cout,Person &p)
{
cout << p.m_A << "-------" << p.m_B ;
return cout;
}
void test01()
{
Person p1;
p1.m_A = 1;
p1.m_B = 1;
//cout << p1; //1
cout << p1 << endl;//2
}
int main()
{
test01();
system("pause");
return 0;
}
第四部分实现递增运算符重载
代码如下：
点击查看代码
//递增运算符重载
#include<iostream>
using namespace std;
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
MyInteger()
{
m_Num = 0;
}
//重载分为前置和后置
//前置
//返回引用是为了一直对一个数据进行递增操作
// MyInteger operator++()
MyInteger& operator++()
{
//先进行++
m_Num++;
//再返回自身
return *this;
}
//后置
//int 代表占位参数 可以用于区分前置和后置递增
MyInteger operator++(int)
{
//先去记录当时的结果
//
MyInteger temp = *this;
//再去递增
//
m_Num++;
//将记录的结果返回
return temp;
//局部对象返回值
}
private:
int m_Num;
};
ostream& operator<<(ostream& cout, MyInteger myint)
{
cout << myint.m_Num;
return cout;
}
void test01()
{
/*MyInteger myint1;
cout << ++(++myint1) << endl;
cout << myint1 << endl;*/
//需要重载++运算符
//后置
MyInteger myint1;
cout <<myint1++<< endl;
cout << myint1 << endl;
//前置
MyInteger myint2;
cout << ++myint2 << endl;
cout << myint2 << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
//前置递增返回的是引用
//后置递增返回的是值
第五部分实现递减运算符重载
代码如下：
点击查看代码
#include<iostream>
using namespace std;
class MyInteger
{
friend ostream& operator<<(ostream& cout, MyInteger m);
//前置--
public:
MyInteger()
{
m_Num = 0;
}
MyInteger& operator--()
{
m_Num--;
return *this;
}
//后置--
MyInteger operator--(int)
{
//MyInteger t = m_Num;
MyInteger t = *this;
m_Num--;
return t;
}
private:
int m_Num;
};
ostream& operator<<(ostream &cout,MyInteger m)
{
cout << m.m_Num;
return cout;
}
void test01()
{
MyInteger m;
cout << m << endl;
//后置
MyInteger myint1;
cout << myint1-- << endl;
cout << myint1 << endl;
//前置
MyInteger myint2;
cout << --myint2 << endl;
cout << myint2 << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
浙公网安备 33010602011771号