运算符重载
- 运算符重载
- 一、重载‘+’运算符
- 1.非成员函数版本重载
- 2.成员函数版本
- 二、重载关系运算符
- 三、重载左移运算符
- 四、重载下标运算符
- 五、重载赋值运算符
- 六、重载new和delete
- 1.重载
- 2.内存池
- 七、重载括号运算符
- 八、重载一元运算符
运算符重载
C++将运算符重载扩展到自定义的数据类型，它可以让对象操作更美观。
例如字符串string用加号（+）拼接，cout用两个左尖括号（<<）输出。
语法：返回值 operator 运算符（参数列表）
非成员函数版本的重载运算符函数：形参个数与运算符操作数个数相同；
成员函数版本的重载运算符函数：形参个数比运算符的操作数个数少一个，其中一个操作数隐式传递了调用对象。
一、重载‘+’运算符
1.非成员函数版本重载
#include<iostream>
using namespace std;
class CStudent
{
public:
int score;
int ID;
CStudent(){score=80;ID=0;}
void show(){cout<<"ID:"<<ID<<endl;cout<<"分数："<<score<<endl;}
};
void operator+(CStudent &s,int a)
{
s.score=s.score+a;
}
int main()
{
CStudent s;
operator+(s,1);
s.show();
s+2;
s.show();
return 0;
}
执行结果：
空返回值的运算符重载有个弊端，就是在同一条语句下不能连续使用，如：
如果需要在同一条语句中连续使用，返回值类型不能为空。如下所示：
#include<iostream>
using namespace std;
class CStudent
{
public:
int score;
int ID;
CStudent(){score=80;ID=0;}
void show(){cout<<"ID:"<<ID<<endl;cout<<"分数："<<score<<endl;}
};
CStudent& operator+(CStudent &s,int a)//返回值类型不为空
{
s.score=s.score+a;
return s;
}
int main()
{
CStudent s;
operator+(s,1);
s.show();
s+2+3 ;
s.show();
return 0;
}
执行结果：
2.成员函数版本
看下面的例子：
说明：成员函数运算符重载里只能有一个参数。
对于+号运算符来说，类外运算符重载和运算符重载同时存在时，系统会不知道调用哪一个，所以要去掉类外运算符重载。
#include<iostream>
using namespace std;
class CStudent
{
public:
int score;
int ID;
CStudent(){score=80;ID=0;}
void show(){cout<<"ID:"<<ID<<endl;cout<<"分数："<<score<<endl;}
void operator+(int b){this->score=this->score+b;}
};
// CStudent& operator+(CStudent &s,int a)
// {
// s.score=s.score+a;
// return s;
// }
int main()
{
CStudent s;
s.operator+(1);
s.show();
s+5;
s.show();
return 0;
}
执行结果：
同理，返回值类型为void 时，运算符在同一条语句中不能连用，需将返回值返回一个对象引用
#include<iostream>
using namespace std;
class CStudent
{
public:
int score;
int ID;
CStudent(){score=80;ID=0;}
void show(){cout<<"ID:"<<ID<<endl;cout<<"分数："<<score<<endl;}
CStudent& operator+(int b){this->score=this->score+b;return *this;}
};
int main()
{
CStudent s;
(s.operator+(1)).operator+(2);
s.show();
s+5+2;
s.show();
return 0;
}
执行结果：
注意事项：
返回自定义数据类型的引用可以让多个运算符表达式串联起来。（不要返回局部变量的引用）
重载函数参数列表中的顺序决定了操作数的位置。
重载函数的参数列表中至少有一个是用户自定义的类型，防止程序员为内置数据类型重载运算符。
如果运算符重载既可以是成员函数也可以是全局函数，应该优先考虑成员函数，这样更符合运算符重载的初衷。
重载函数不能违背运算符原来的含义和优先级。
不能创建新的运算符。
以下运算符只通过成员函数进行重载：
= 赋值运算符
()函数调用运算符
[]下标运算符
->通过指针访问类成员的运算符
二、重载关系运算符
关系运算符有：==、！=、>、>=、<、<=用于比较两个自定义数据类型的大小。重载关系运算符时尽量使用成员函数版本。
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{}
bool operator==(CStudent &rhs)
{
if((this->chinese+this->math+this->english)==(rhs.chinese+rhs.english+rhs.math))
return true;
return false;
}
};
int main()
{
CStudent s1("李华",85,92,95);
CStudent s2("李明",82,94,96);
if(s1==s2)
{
cout<<"李华和李明成绩一样！"<<endl;
}
else
cout<<"李华和李明成绩不一样！"<<endl;
return 0;
}
执行结果：
三、重载左移运算符
重载左移运算符(<<)用于输出自定义对象的成员变量，在实际开发中很有价值(调试和日志） 只能使用非成员函数版本。
如果输出对象的私有成员，可以配合友元一起使用。
语法：
ostream& operator<<(ostream& cout,constant type& rhs)
{
cout<<rhs.xxx<<……<<endl;
return cout;
}
示例：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{}
};
ostream &operator<<(ostream& cout,const CStudent&s)
{
cout<<"姓名："<<s.name<<"\n语文成绩："<<s.chinese<<"\n数学成绩："<<s.math<<"\n英语成绩："<<s.english<<endl;
return cout;
}
int main()
{
CStudent s("小明",88,79,92);
cout<<s;
return 0;
}
运行结果：
四、重载下标运算符
如果对象中有数组，重载下标运算符[]，操作对象中的数组将像操作普通数组一样方便。
下标运算符必须以成员函数的形式进行重载。
语法：
返回值类型 &operator 或者：const 返回值类型 &operator[](参数）const
使用第一种声明方式，[]不公可以访问数组元素，还可以修改数组元素。 使用第二种声明方式，[]只能访问不能修改数组元素。
在实际开发中，两种都要提供，目的是为了迁就常对象，因为常对象不能访问非常函数。
看下面的例子：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
string &operator[](int i)
{
return this->friends[i];
}
};
int main()
{
const CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
return 0;
}
执行结果：
结论：常对象不能访问非常成员函数
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
string &operator[](int i)
{
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
return 0;
}
执行结果：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
string &operator[](int i)
{
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
s[2]="小北";
cout<<s[2]<<endl;
return 0;
}
执行结果：
> 说明：可以通过重载下标运算符来访问和修改成员变量。
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
const string &operator[](int i)//表示返回值不允许修改
{
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
s[2]="小北";
cout<<s[2]<<endl;
return 0;
}
执行结果：
结论：重载下标运算符的返回值为常引用时，不允许修改成员变量。
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
string &operator[](int i)const//常成员函数，注意const的位置。
{
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
s[2]="小北";
cout<<s[2]<<endl;
return 0;
}
执行结果：
结论：常成员函数不允许访问非常成员变量。
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
const string &operator[](int i)//表示返回值不允许修改,但重载函数内部可以修改
{
this->friends[i]="小豪";
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
return 0;
}
执行结果：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
const string &operator[](int i)const//表示返回值不允许修改,重载函数内部也不可以修改
{
this->friends[i]="小豪";
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
return 0;
}
执行结果：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
const string &operator[](int i)const
{
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
return 0;
}
执行结果：
结论：非常对象可以访问常成员函数
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
string &operator[](int i)const
{
return this->friends[i];
}
};
int main()
{
CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
return 0;
}
执行结果：
没有首const 不能访问非常成员变量
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
const string &operator[](int i)
{
return this->friends[i];
}
};
int main()
{
const CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
return 0;
}
执行结果：
常对象不能访问非常成员函数
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
string &operator[](int i)
{
return this->friends[i];
}
const string &operator[](int i)const
{
return this->friends[i];
}
};
int main()
{
const CStudent s("小明",88,79,92);
cout<<s[2]<<endl;
CStudent s1("小叶",92,85,93);
s1[2]="小明";
cout<<s1[2]<<endl;
return 0;
}
执行结果：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
string &operator[](int i)
{
return this->friends[i];
}
const string &operator[](int i)const
{
return this->friends[i+1];
}
};
int main()
{
const CStudent s("小明",88,79,92);
cout<<s[1]<<endl;
CStudent s1("小叶",92,85,93);
cout<<s1[1]<<endl;
return 0;
}
执行结果：
说明：非常对象优先调用非常成员函数重载，常对象优先调用常成员函数重载。
五、重载赋值运算符
C++编译器可能会给类型添加四个函数：
默认构造函数，空实现。
默认析构函数，空实现。
默认挎贝构造函数，对成员变量进行浅挎贝。
默认赋值函数，对成员变量进行浅挎贝。
对象的赋值运算是用一个已经存在的对象，给另一个已经存在的对象赋值。
如果类的定义中没有重载赋值函数，编译器就会提供一个默认的赋值函数。
如果类中重载了赋值函数，编译器将不提供默认赋值函数。
请看下面的例子：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
};
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
s1=s;
cout<<s1.chinese<<endl;
return 0;
}
执行结果：
定义了带参构造函数，默认的空无参构造函数失效。
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
CStudent(){}
};
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
s1=s;
cout<<s1.chinese<<endl;
return 0;
}
执行结果：
说明：上述代码对构造函数进行了重载
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
CStudent(){}
};
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
s1=s;
cout<<s1.friends[1]<<endl;
return 0;
}
执行结果：
说明：数组也能赋值
对数组来说，这是一种深挎贝：
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
cout<<s.friends<<endl;
s1=s;
cout<<s1.friends<<endl;
cout<<s1.friends[1]<<endl;
return 0;
}
执行结果：
重载赋值函数语法：类名 & operator=(const 类名 & 源对象)
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
CStudent(){}
CStudent &operator=(const CStudent& s)
{
if(this==&s)return *this;
this->name=s.name;
this->english=s.english;
this->chinese=s.chinese;
this->math=s.math;
for(int i=0;i<3;++i)
{
this->friends[i]=s.friends[i];
}
return *this;
}
};
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
s1=s;
cout<<s1.name<<endl;
cout<<s1.math<<endl;
cout<<s1.friends[2]<<endl;
return 0;
}
执行结果：
编译器默认的赋值函数是浅挎贝。如果对象中不存在堆区内存空间，默认赋值函数可以满足需求，否则需要深挎贝。
赋值运算和挎贝构造不同：拷贝构造是指对象不存在，用已存在的对象进行构造；赋值运算是指已经存在了两个对象，把其中一个对象的成员变量的值赋给另一个对象的成员变量。
#include<iostream>
#include<memory.h>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
int* m_ptr;//计划使用堆区内存
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
m_ptr=nullptr;
}
CStudent(){}
CStudent &operator=(const CStudent& s)
{
if(this==&s)return *this;
this->name=s.name;
this->english=s.english;
this->chinese=s.chinese;
this->math=s.math;
for(int i=0;i<3;++i)
{
this->friends[i]=s.friends[i];
}
if(s.m_ptr==nullptr)//如果源对象的指针为空，则清空目标对象的内存和指针
{
if(m_ptr!=nullptr){delete m_ptr;m_ptr=nullptr;}
}
else //如果源对象的指针不为空
{
//如果目标对象的指针为空，先分配内存
if(m_ptr==nullptr)m_ptr=new int;
//然后，把源对象内存中的数据复制到目标对象的内存中
memcpy(m_ptr,s.m_ptr,sizeof(int));
}
return *this;
}
~CStudent(){
delete m_ptr;
}
};
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
cout<<s.m_ptr<<endl;
s1.m_ptr=new int(3);
cout<<s1.m_ptr<<endl;
s1=s;
cout<<s1.m_ptr<<endl;
return 0;
}
执行结果：
如果对象中存在堆内存空间，一定要在构造函数中初始化对象，否则会产生意想不到的异常。如下：
#include<iostream>
#include<memory.h>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
int* m_ptr;//计划使用堆区内存
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
cout<<"调用带参构造函数"<<endl;
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
m_ptr=nullptr;
}
CStudent(){
cout<<"调用无参构造函数"<<endl;
// m_ptr=nullptr;//没有进行初始化
}
CStudent &operator=(const CStudent& s)
{
if(this==&s)return *this;
this->name=s.name;
this->english=s.english;
this->chinese=s.chinese;
this->math=s.math;
for(int i=0;i<3;++i)
{
this->friends[i]=s.friends[i];
}
if(s.m_ptr==nullptr)//如果源对象的指针为空，则清空目标对象的内存和指针
{
if(m_ptr!=nullptr){delete m_ptr;m_ptr=nullptr;}
}
else //如果源对象的指针不为空
{
//如果目标对象的指针为空，先分配内存
if(m_ptr==nullptr)m_ptr=new int;
//然后，把源对象内存中的数据复制到目标对象的内存中
memcpy(m_ptr,s.m_ptr,sizeof(int));
}
return *this;
}
~CStudent(){
delete m_ptr;
}
};
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
s.m_ptr=new int(3);
s1=s;
cout<<s.m_ptr<<endl;
cout<<s1.m_ptr<<endl;
cout<<*(s1.m_ptr)<<endl;
return 0;
}
执行结果：
说明：产生了异常
改进：
#include<iostream>
#include<memory.h>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
int* m_ptr;//计划使用堆区内存
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
cout<<"调用带参构造函数"<<endl;
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
m_ptr=nullptr;
}
CStudent(){
cout<<"调用无参构造函数"<<endl;
m_ptr=nullptr;
}
CStudent &operator=(const CStudent& s)
{
if(this==&s)return *this;
this->name=s.name;
this->english=s.english;
this->chinese=s.chinese;
this->math=s.math;
for(int i=0;i<3;++i)
{
this->friends[i]=s.friends[i];
}
if(s.m_ptr==nullptr)//如果源对象的指针为空，则清空目标对象的内存和指针
{
if(m_ptr!=nullptr){delete m_ptr;m_ptr=nullptr;}
}
else //如果源对象的指针不为空
{
//如果目标对象的指针为空，先分配内存
if(m_ptr==nullptr)m_ptr=new int;
//然后，把源对象内存中的数据复制到目标对象的内存中
memcpy(m_ptr,s.m_ptr,sizeof(int));
}
return *this;
}
~CStudent(){
delete m_ptr;
}
};
int main()
{
CStudent s("小明",88,79,92);
CStudent s1;
s.m_ptr=new int(3);
s1=s;
cout<<s.m_ptr<<endl;
cout<<s1.m_ptr<<endl;
cout<<*(s1.m_ptr)<<endl;
return 0;
}
执行结果：
说明：在构造函数中初始化对象后就没问题了。
六、重载new和delete
1.重载
重载new和delete运算符的目的是为了自定义内存分配的细节。（内存池：快速分配和归还，无碎片）
在c++中，使用new时，编译器做了两件事：
1)调用标准库函数operator new()分配内存；
2)调用构造函数初始化内存；
使用delete时，也做了两件事情：
1)调用析构函数；
2)调用标准库函数operator delete()释放内存。
构造函数和析构函数由编译器的调用，我们无法控制。但是可以重载内存分配函数operator new()和释放函数operator delete();
1.重载内存分配函数语法：void* operator new(size_t size);
参数必须是size_t,返回值必须是void*.
2.重载内存释放函数的语法：void operator delete(void* ptr)
参数必须是void (指向由operator new()分配的内存），返回值必须是void .
重载的new和delete时，尽管不必显式地使用static,但实际上仍在创建static成员函数。
void表示该指针指向的是一块与类型无关的内存空间
下面演示为整型变量动态分配内存：
#include<iostream>
using namespace std;
void* operator new(size_t size)//参数必须是size_t(unsigned long long),返回值必须是void*.
{
cout<<"调用了重载的new："<<size<<"字节。\n";
void* ptr=malloc(size);//申请内存
cout<<"申请到的内存的地址是："<<ptr<<endl;
return ptr;
}
void operator delete(void* ptr)//参数必须是void*,返回值必须是void.
{
cout<<"调用了重载的delete.\n";
if(ptr==0)return;//对空指针delete是安全的
free(ptr);//释放内存
}
int main()
{
int *p1=new int(3);
cout<<"p1="<<(void*)p1<<", *p1="<<*p1<<endl;
delete p1;
return 0;
}
执行结果：
下面演示为类动态分配内存：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
string friends[3];
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
friends[0]="小华";
friends[1]="小红";
friends[2]="小方";
}
};
void* operator new(size_t size)//参数必须是size_t(unsigned long long),返回值必须是void*.
{
cout<<"调用了重载的new："<<size<<"字节。\n";
void* ptr=malloc(size);//申请内存
cout<<"申请到的内存的地址是："<<ptr<<endl;
return ptr;
}
void operator delete(void* ptr)//参数必须是void*,返回值必须是void.
{
cout<<"调用了重载的delete.\n";
if(ptr==0)return;//对空指针delete是安全的
free(ptr);//释放内存
}
int main()
{
CStudent *p2=new CStudent("小明",89,85,86);
cout<<"p2的地址是："<<p2<<"姓名："<<p2->name<<",朋友2："<<p2->friends[1]<<endl;
delete p2;
return 0;
}
执行结果：
说明：调用了那么多次有可能是使用了string的原因。
以下来验证（删除string数组）：
#include<iostream>
using namespace std;
class CStudent{
public:
string name;//这个name是一个指针（8个字节）
int chinese;
int math;
int english;
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
}
};
void* operator new(size_t size)//参数必须是size_t(unsigned long long),返回值必须是void*.
{
cout<<"调用了重载的new："<<size<<"字节。\n";
void* ptr=malloc(size);//申请内存
cout<<"申请到的内存的地址是："<<ptr<<endl;
return ptr;
}
void operator delete(void* ptr)//参数必须是void*,返回值必须是void.
{
cout<<"调用了重载的delete.\n";
if(ptr==0)return;//对空指针delete是安全的
free(ptr);//释放内存
}
int main()
{
CStudent *p2=new CStudent("小明",89,85,86);
cout<<"p2的地址是："<<p2<<"姓名："<<p2->name<<endl;
delete p2;
return 0;
}
执行结果：
说明：的确的string的原因。
int test[5];
cout<<sizeof(p2->test)<<endl;
执行结果：
说明：对于像数组这样的静态指针来说，sizeof是可以识别出它所指向的内存大小的。
#include<iostream>
#include<vector>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
vector<int>test{1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9};
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
}
};
void* operator new(size_t size)//参数必须是size_t(unsigned long long),返回值必须是void*.
{
cout<<"调用了重载的new："<<size<<"字节。\n";
void* ptr=malloc(size);//申请内存
cout<<"申请到的内存的地址是："<<ptr<<endl;
return ptr;
}
void operator delete(void* ptr)//参数必须是void*,返回值必须是void.
{
cout<<"调用了重载的delete.\n";
if(ptr==0)return;//对空指针delete是安全的
free(ptr);//释放内存
}
int main()
{
CStudent *p2=new CStudent("小明小方小蓝",89,85,86);
cout<<"p2的地址是："<<p2<<endl<<"姓名："<<p2->name<<endl;
cout<<sizeof(*p2)<<endl;
delete p2;
return 0;
}
执行结果：
说明：STL变量的本质就是一个指针，虽然不是动态的，但sizeof 无法识别。
#include<iostream>
#include<vector>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
vector<int>test{1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9};
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
}
void* operator new(size_t size)//参数必须是size_t(unsigned long long),返回值必须是void*.
{
cout<<"调用了类的重载的new："<<size<<"字节。\n";
void* ptr=malloc(size);//申请内存
cout<<"申请到的内存的地址是："<<ptr<<endl;
return ptr;
}
void operator delete(void* ptr)//参数必须是void*,返回值必须是void.
{
cout<<"调用了类的重载的delete.\n";
if(ptr==0)return;//对空指针delete是安全的
free(ptr);//释放内存
}
};
void* operator new(size_t size)//参数必须是size_t(unsigned long long),返回值必须是void*.
{
cout<<"调用了全局重载的new："<<size<<"字节。\n";
void* ptr=malloc(size);//申请内存
cout<<"申请到的内存的地址是："<<ptr<<endl;
return ptr;
}
void operator delete(void* ptr)//参数必须是void*,返回值必须是void.
{
cout<<"调用了全局重载的delete.\n";
if(ptr==0)return;//对空指针delete是安全的
free(ptr);//释放内存
}
int main()
{
CStudent *p2=new CStudent("小明小方小蓝",89,85,86);
cout<<"p2的地址是："<<p2<<endl<<"姓名："<<p2->name<<endl;
cout<<sizeof(*p2)<<endl;
delete p2;
return 0;
}
执行结果：
说明：string 用的是全局new
CStudent用的是类的new
为一个类重载New和delete时，尽管不必显式地使用static,但实际上仍在创建static成员函数。
编译器看到使用new创建自定义类的对象时，它选择成员版本的operator new()而不是全局版的new().
new[]和delete[]也可以重载。
2.内存池
预先分配一大块内存空间
提升分配和归还速度
减少内存碎片
#include<iostream>
#include<memory.h>
#include<vector>
using namespace std;
class CStudent{
public:
string name;
int chinese;
int math;
int english;
static char* m_pool;//内存池的起始地址
static bool initpool()//初始化内存池的函数
{
m_pool=(char*)malloc(50);
if(m_pool==0)return false;//如果申请失败，返回false
memset(m_pool,0,50);//把内存池中的内容初始化为0
cout<<"内存池的起始地址是:"<<(void*)m_pool<<endl;
return true;
}
static void freepool()
{
if(m_pool==0)return ;//如果内存池为空，不需要释放，直接返回
free(m_pool);//把内存池归还给系统
cout<<"内存池已释放。\n"<<endl;
}
CStudent(string s_name,int s_chinese, int s_math, int m_english):
name(s_name),chinese(s_chinese),math(s_math),english(m_english)
{
}
void* operator new(size_t size)//参数必须是size_t(unsigned long long),返回值必须是void*.
{
if(m_pool[0]==0)//判断第一个位置是否空闲
{
cout<<"分配了第一块内存："<<(void*)(m_pool+1)<<endl;
m_pool[0]=1;//把第一个位置标记为已分配
return m_pool+1;//返回第一个存放对象的地址
}
if(m_pool[25]==0)
{
cout<<"分配了第二块内存："<<(void*)(m_pool+1)<<endl;
m_pool[25]=1;//把第一个位置标记为已分配
return m_pool+26;//返回第一个存放对象的地址
}
//如果以上两位置都不可用，那主直接系统申请内存
void *ptr=malloc(size);//申请内存
cout<<"申请到的内存地址是："<<ptr<<endl;
return ptr;
}
void operator delete(void* ptr)//参数必须是void*,返回值必须是void.
{
if(ptr==0)return;//如果传进来的地址为空 ，直接返回
if(ptr==m_pool+1)//如果传进来的地址是内存池的第一个位置
{
cout<<"释放第一块内存。\n";
m_pool[0]=0;//把第一个位置标记为空闲
return ;
}
if(ptr==m_pool+26)//如果传进来的地址是内存池的第二个位置
{
cout<<"释放第二块内存。\n";
m_pool[25]=0;
return ;
}
//如果传进来的地址不属于内存池，把它归还给系统
cout<<"释放其他内存块。\n"<<endl;
free(ptr);
}
};
char* CStudent::m_pool=0;//初始化内存池的指针
int main()
{
//初始化内存池
if(CStudent::initpool()==false){cout<<"初始化内存池失败。\n";return -1;}
CStudent *p1=new CStudent("小方",89,85,86);
cout<<"sizeof(*p1):"<<sizeof(*p1)<<endl;
CStudent *p2=new CStudent("小方",89,85,86);
cout<<"sizeof(*p2):"<<sizeof(*p2)<<endl;
CStudent *p3=new CStudent("小方",89,85,86);
cout<<"sizeof(*p3):"<<sizeof(*p3)<<endl;
delete p1;
delete p2;
delete p3;
CStudent::freepool();
return 0;
}
执行结果：
上面只是演示，这个内存池是有一堆bug的
七、重载括号运算符
括号运算符也可以重载，对象名可以当成函数来使用(函数对象、仿函数)。
括号运算符重载函数的语法：
返回值类型 operator()(参数列表)
注意：
括号运算符必须以成员函数的形式进行重载。
括号运算符重载函数具备普通函数全部的特征。
如函数对象与全局函数同名，按作用域规则选择调用的函数
请看下面例子：
#include<iostream>
using namespace std;
void show(string str)
{
cout<<"普通函数："<<str<<endl;
}
class CStudent
{
public:
void operator()(string str)//重载()运算符
{
cout<<"重载函数："<<str<<endl;
}
};
int main()
{
CStudent s;
s("我是一只小菜鸟。");//使用重载的括号运算符
show("我是一只小菜鸟。");
return 0;
}
执行结果：
#include<iostream>
using namespace std;
void show(string str)
{
cout<<"普通函数："<<str<<endl;
}
class CStudent
{
public:
void operator()(string str)//重载()运算符
{
cout<<"重载函数："<<str<<endl;
}
};
int main()
{
CStudent show;
show("我是一只小菜鸟。");//使用重载的括号运算符
show("我是一只小菜鸟。");
return 0;
}
执行结果：
当普通函数和重载函数同时出现时，优先调用重载函数。
如何解决这个问题？
使用::，表示使用的是全局函数
#include<iostream>
using namespace std;
void show(string str)
{
cout<<"普通函数："<<str<<endl;
}
class CStudent
{
public:
void operator()(string str)//重载()运算符
{
cout<<"重载函数："<<str<<endl;
}
};
int main()
{
CStudent show;
show("我是一只小菜鸟。");//使用重载的括号运算符
::show("我是一只小菜鸟。");
return 0;
}
执行结果：
函数对象的用途：
1)表面像函数，部分场景中可以代替函数，在STL中得到广泛的应用；
2)函数对象的本质是类，可以用成员变量存放更多的信息；
3)函数对象有自己的数据类型；
4)可以提供继承体系。
八、重载一元运算符
下表为可重载的一元运算符：
一元运算符通常出现在它们所操作的对象的左边。
但是，自增运算符++和自减运算符–有前置和后置之分。
为了解决这个问题，C++规定，在重载++或–时，允许写一个增加了int形参的版本，编译器处理后置表达式时，
以下代码编译会报错：
#include<iostream>
using namespace std;
class CStudent
{
public:
string m_name;
int m_ranking;//排名
//默认构造函数
CStudent(){m_name="小明";m_ranking=5;}
//自我介绍的方法
void show()const{cout<<"姓名："<<m_name<<",排名："<<m_ranking<<endl;}
void operator++()
{
m_ranking++;
}
};
int main()
{
CStudent s;
s++;
return 0;
}
说明：因为没有重载类的后置++
再看下面的代码：
#include<iostream>
using namespace std;
class CStudent
{
public:
string m_name;
int m_ranking;//排名
//默认构造函数
CStudent(){m_name="小明";m_ranking=5;}
//自我介绍的方法
void show()const{cout<<"姓名："<<m_name<<",排名："<<m_ranking<<endl;}
void operator++()
{
m_ranking++;
}
};
int main()
{
CStudent s;
++s;
s.show();
return 0;
}
执行结果：
但是上面的代码不够完美，因为不可以连续前置++
#include<iostream>
using namespace std;
class CStudent
{
public:
string m_name;
int m_ranking;//排名
//默认构造函数
CStudent(){m_name="小明";m_ranking=5;}
//自我介绍的方法
void show()const{cout<<"姓名："<<m_name<<",排名："<<m_ranking<<endl;}
void operator++()
{
m_ranking++;
}
};
int main()
{
CStudent s;
++(++s);
s.show();
return 0;
}
如何解决？返回对象的引用：
#include<iostream>
using namespace std;
class CStudent
{
public:
string m_name;
int m_ranking;//排名
//默认构造函数
CStudent(){m_name="小明";m_ranking=5;}
//自我介绍的方法
void show()const{cout<<"姓名："<<m_name<<",排名："<<m_ranking<<endl;}
CStudent& operator++()
{
m_ranking++;
}
};
int main()
{
CStudent s;
++(++s);
s.show();
return 0;
}
执行结果：
如何重载后置++？
#include<iostream>
using namespace std;
class CStudent
{
public:
string m_name;
int m_ranking;//排名
//默认构造函数
CStudent(){m_name="小明";m_ranking=5;}
//自我介绍的方法
void show()const{cout<<"姓名："<<m_name<<",排名："<<m_ranking<<endl;}
CStudent& operator++()
{
m_ranking++;
return *this;
}
CStudent& operator++(int)//int形参
{
m_ranking++;
return *this;
}
};
int main()
{
CStudent s;
s++;
s.show();
return 0;
}
执行结果：
上面的代码也是有问题的请看下面的例子：
标准的c++不支持后置++连续使用
#include<iostream>
using namespace std;
class CStudent
{
public:
string m_name;
int m_ranking;//排名
//默认构造函数
CStudent(){m_name="小明";m_ranking=5;}
//自我介绍的方法
void show()const{cout<<"姓名："<<m_name<<",排名："<<m_ranking<<endl;}
CStudent& operator++()
{
m_ranking++;
return *this;
}
CStudent& operator++(int)
{
m_ranking++;
return *this;
}
};
int main()
{
CStudent s1,s2;
int ii=5,jj=5;
int xx=++(++(++ii));cout<<"xx="<<xx<<",ii="<<ii<<endl;
int yy=jj++;;cout<<"yy="<<yy<<",jj="<<jj<<endl;
((s2++)++)++;
s2.show();
return 0;
}
执行结果：
然而上面的定义却支持嵌套后置++，虽然支持，但最好别用
再看下面的例子：
#include<iostream>
using namespace std;
class CStudent
{
public:
string m_name;
int m_ranking;//排名
//默认构造函数
CStudent(){m_name="小明";m_ranking=5;}
//自我介绍的方法
void show()const{cout<<"姓名："<<m_name<<",排名："<<m_ranking<<endl;}
CStudent& operator++()
{
m_ranking++;
return *this;
}
CStudent& operator++(int)
{
m_ranking++;
return *this;
}
};
int main()
{
CStudent s1,s2;
int ii=5,jj=5;
int xx=++(++(++ii));cout<<"xx="<<xx<<",ii="<<ii<<endl;
int yy=jj++;;cout<<"yy="<<yy<<",jj="<<jj<<endl;
CStudent s3=++(++(++s1));cout<<"s3.m_ranking="<<s3.m_ranking<<",s1.m_ranking="<<s1.m_ranking<<endl;
CStudent s4=s2++;cout<<"s4.m_ranking="<<s4.m_ranking<<",s2.m_ranking="<<s2.m_ranking<<endl;
return 0;
}
执行结果：
说明：显然类重载后的后置++运算符与整数运算的效果不一样，这个结果不符合++运算符的后置语义。
改进方法：
CStudent operator++(int)
{
CStudent tmp=*this;
m_ranking++;
return tmp;
}
执行结果：
但注意函数的返回值不能是引用，否则：
CStudent &operator++(int)
{
CStudent tmp=*this;
m_ranking++;
return tmp;
}
执行结果：
总结：
学习链接
