- 必须是成员函数，不能是友元函数。
- 没有参数（操作数是什么？）。
- 不能指定返回类型（其实已经指定了）。
- 函数原型：operator 类型名();
下面用代码来说明，先新建工程，将上次实现的Integer类添加至项目中来：
Integer.h:
#ifndef _INTEGER_H
#define _INTEGER_H
class Integer
{
public:
Integer(int n);
~Integer();
void display() const;
//Integer& operator ++();//++运算符重载
friend Integer& operator ++(Integer& i);//友元方式重载前置++
friend Integer operator ++(Integer& i, int n);//友元方式重载后置++
//Integer operator ++(int i);//后置++运算符重载,其中的参数并没啥用，只是为了和前置++形成重载
private:
int n_;
};
#endif //_INTEGER_H
Integer.cpp:
#include "Integer.h"
#include <iostream>
using namespace std;
Integer::Integer(int n) : n_(n) {
}
Integer::~Integer()
{
}
//Integer& Integer::operator ++() {
// ++n_;
// return *this;
//}
Integer& operator ++(Integer& i) {
++i.n_;
return i;
}
//Integer Integer::operator ++(int i) {
// Integer tmp(n_);//构造一个临时对象
// n_++;//紧接着再来修改n_
// return tmp;//这时返回的是对象，而不是引用了，因为如果是引用，临时对象会被回收，则指向了一个无效的对象了
//}
Integer operator ++(Integer& i, int n) {
Integer tmp(i.n_);//构造一个临时对象
i.n_++;//紧接着再来修改n_
return tmp;//这时返回的是对象，而不是引用了，因为如果是引用，临时对象会被回收，则指向了一个无效的对象了
}
void Integer::display() const{
cout<<n_<<endl;
}
测试代码：
#include "Integer.h"
#include <iostream>
using namespace std;
int main(void) {
Integer n(100);
n = 200;//可以将一个整型转换成类类型，因为实现了转换构造函数
n.display();
return 0;
}
上面的输出的写法及输出结果显而易见，就不多说了，接下来实现加法运算的函数：
很遗憾，这样的写法目前还不支持：
这时需要重写类型转换运算符了，下面来实现一下：
再次编译运行:
实际上用一个更加直观的例子更能看明白：
结果：
这是隐式转换，其实也可以使用显示转换：
直接来代码，这里为了方便直接将类写在main函数文件中，举一个数据库相关的例子：
#include <iostream>
using namespace std;
class DB {
public:
DB() {
cout<<"DB ..."<<endl;
}
~DB() {
cout<<"~DB ..."<<endl;
}
void open() {//数据库打开
cout<<"~open ..."<<endl;
}
void close() {//数据库关闭
cout<<"~close ..."<<endl;
}
void query() {//数据库查询
cout<<"~query ..."<<endl;
}
};
int main(void) {
DB* db = new DB();
db->open();
db->query();
db->close();
delete db;
return 0;
}
编译运行:
但是说到数据库的关闭，可能在实际的程序中并没有这么简单，因为不知道它何时释放，我们想当数据库对象销毁的时候自动关闭，那首先能想到的办法是：
#include <iostream>
using namespace std;
class DB {
public:
DB() {
cout<<"DB ..."<<endl;
open();
}
~DB() {
cout<<"~DB ..."<<endl;
close();
}
void open() {//数据库打开
cout<<"~open ..."<<endl;
}
void close() {//数据库关闭
cout<<"~close ..."<<endl;
}
void query() {//数据库查询
cout<<"~query ..."<<endl;
}
};
int main(void) {
DB* db = new DB();
//db->open();
db->query();
//db->close();
delete db;
return 0;
}
其运行结果也是一样的，但是这种方案也不是很可取，一是构造里面的数据库打开比较耗时，在构造函数中不宜做太多事，另外在实际中也能难找到合适的delete销毁对象的地方，也就不能调用close()方法了，我们希望在对象的生命周期结束的时候能够被自动释放，可以采取另外一种方案，具体如下：
#include <iostream>
using namespace std;
class DBHelper {//将原来的类改名了
public:
DBHelper() {
cout<<"DB ..."<<endl;
}
~DBHelper() {
cout<<"~DB ..."<<endl;
}
void open() {//数据库打开
cout<<"~open ..."<<endl;
}
void close() {//数据库关闭
cout<<"~close ..."<<endl;
}
void query() {//数据库查询
cout<<"~query ..."<<endl;
}
};
class DB {//新声明一个类
public:
DB() {
db_ = new DBHelper();
}
~DB() {
delete db_;
}
DBHelper* operator->() {//重写指针运算符
return db_;
}
private:
DBHelper* db_;
};
int main(void) {
DB db;
db->open();//为啥对象可以直接用指针调用，也就是由于DB重写了指针运算符了
db->query();
db->close();
return 0;
}
编译运行：
这样写有什么好处呢？可以很灵活的释放动态对象，利用的是确定性析构的办法，DB对象在生命周期开始时一定会调用构造函数，而当生命周期结束之后一定会调用析构函数，从而释放了所包装的DBHelper对象，使得我们对内存的控制更加方便，实际上这也是智能指针实现的一个技巧，就相当于DB是一个智能指针【smart pointer：关于智能指针之后会仔细学习，巧妙的使用智能指能能够避免内存泄漏】，它包装了DBHelper
先回顾一下new的三种用法：new operator、operator new、placement new
下面来用代码说明以上三种new的用法：
#include <iostream>
using namespace std;
class Test {
public:
Test(int n): n_(n) {
cout<<"Test(int n): n_(n)"<<endl;
}
Test(const Test& other) {
cout<<"Test(const Test& other)"<<endl;
}
~Test() {
cout<<"~Test()"<<endl;
}
private:
int n_;
};
int main(void) {
Test* p1 = new Test(10);//它是new operator=operator new + 构造函数的调用
return 0;
}
实际上可以debug一下既可看出是否是如上面所说的那样：
按F11跟踪进去：
跳出该方法，继续按F11跟踪，会发现调用了构造函数了：
通过这个过程可以清楚的了解到new operator操作的内部执行过程。
所以对于"new operator、operator new"的这两种new的用法已经清楚了，那接下来说明一下它的最后一种用法：“placement new”：
编译运行：
从结果打印来看是一样的，为了进一步说明，可以debug一下：
其中operator new是可以被重载的，但是new operator是不能的，下面来看下相关的语法：
- void* operator new(size_t size)
- void operator delete(void* p)
- void operator delete(void* p, size_t size)
- void* operator new(size_t size, const char* file, long line)
- void operator delete(void* p, const char* file, long line)
- void* operator new[](size_t size)
- void operator delete[](void* p)
- void operator delete[](void* p, size_t size)
一旦new运算符被重载了，对应的delete运算符也随之要被重载，是相匹配的，下面来实现下：
#include <iostream>
using namespace std;
class Test {
public:
Test(int n): n_(n) {
cout<<"Test(int n): n_(n)"<<endl;
}
Test(const Test& other) {
cout<<"Test(const Test& other)"<<endl;
}
~Test() {
cout<<"~Test()"<<endl;
}
void* operator new(size_t size) {//重载operator new
cout<<"void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p) {
cout<<"void operator delete(void* p)"<<endl;
free(p);
}
int n_;
};
int main(void) {
Test* p1 = new Test(10);//它是new operator=operator new + 构造函数的调用
delete p1;
char chunk[10];
Test* p2 = new(chunk) Test(200);//placement new:是基于已有的地址来创建对象的，不会分配内存
cout<<p2->n_<<endl;
//Test* p3 = (Test*)chunk;
Test* p3 = reinterpret_cast<Test*>(chunk);
cout<<p3->n_<<endl;
return 0;
}
编译运行：
这是为啥呢？因为下面有个placement new还没有重载，所以为了说明问题先将下面的语句注释掉，之后再来让其编译通过：
再次编译运行：
另外operator delete有两种方式，如下：
那能否共存呢？
编译运行：
可以看出可以共存，默认是调用第一个参数的operator delete，那如果将一个参数的注释掉，程序还会编译通过么？
看结果：
也就是说这两个operator delete都是与operator new相匹配的。
另外operator new分为局部重载和全局重载，像刚才的是属于局部重载，只针对Test类有关，而如果像下面这种new operator呢？
它会不会调用Test类中的operator new运算符呢？答案当然不会，因为这是属于全局的，我们也可以重载全局的operator new，如下：
#include <iostream>
using namespace std;
class Test {
public:
Test(int n): n_(n) {
cout<<"Test(int n): n_(n)"<<endl;
}
Test(const Test& other) {
cout<<"Test(const Test& other)"<<endl;
}
~Test() {
cout<<"~Test()"<<endl;
}
void* operator new(size_t size) {//重载operator new
cout<<"void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
/*void operator delete(void* p) {
cout<<"void operator delete(void* p)"<<endl;
free(p);
}*/
void operator delete(void* p, size_t size) {
cout<<"void operator delete(void* p, size_t size)"<<endl;
free(p);
}
int n_;
};
void* operator new(size_t size) {
cout<<"global void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p) {
cout<<"global void operator delete(void* p)"<<endl;
free(p);
}
int main(void) {
Test* p1 = new Test(10);//它是new operator=operator new + 构造函数的调用
delete p1;
char* str = new char;
delete str;
char chunk[10];
/*Test* p2 = new(chunk) Test(200);//placement new:是基于已有的地址来创建对象的，不会分配内存
cout<<p2->n_<<endl;
//Test* p3 = (Test*)chunk;
Test* p3 = reinterpret_cast<Test*>(chunk);
cout<<p3->n_<<endl;*/
return 0;
}
编译运行：
那如果是new一个数组呢？
可以重载带数组的函数，如下：
#include <iostream>
using namespace std;
class Test {
public:
Test(int n): n_(n) {
cout<<"Test(int n): n_(n)"<<endl;
}
Test(const Test& other) {
cout<<"Test(const Test& other)"<<endl;
}
~Test() {
cout<<"~Test()"<<endl;
}
void* operator new(size_t size) {//重载operator new
cout<<"void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
/*void operator delete(void* p) {
cout<<"void operator delete(void* p)"<<endl;
free(p);
}*/
void operator delete(void* p, size_t size) {
cout<<"void operator delete(void* p, size_t size)"<<endl;
free(p);
}
int n_;
};
void* operator new(size_t size) {
cout<<"global void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p) {
cout<<"global void operator delete(void* p)"<<endl;
free(p);
}
void* operator new[](size_t size) {
cout<<"global void* operator new[](size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete[](void* p) {
cout<<"global void operator delete[](void* p)"<<endl;
free(p);
}
int main(void) {
Test* p1 = new Test(10);//它是new operator=operator new + 构造函数的调用
delete p1;
char* str = new char[100];
delete[] str;
char chunk[10];
/*Test* p2 = new(chunk) Test(200);//placement new:是基于已有的地址来创建对象的，不会分配内存
cout<<p2->n_<<endl;
//Test* p3 = (Test*)chunk;
Test* p3 = reinterpret_cast<Test*>(chunk);
cout<<p3->n_<<endl;*/
return 0;
}
再次编译运行：
可见这次就调用了我们重载的全局数组的operator new函数了。
下面还有这种重载形式没有使用：
那它的作用是什么呢？下面来使用一下：
#include <iostream>
using namespace std;
class Test {
public:
Test(int n): n_(n) {
cout<<"Test(int n): n_(n)"<<endl;
}
Test(const Test& other) {
cout<<"Test(const Test& other)"<<endl;
}
~Test() {
cout<<"~Test()"<<endl;
}
void* operator new(size_t size) {//重载operator new
cout<<"void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
/*void operator delete(void* p) {
cout<<"void operator delete(void* p)"<<endl;
free(p);
}*/
void operator delete(void* p, size_t size) {
cout<<"void operator delete(void* p, size_t size)"<<endl;
free(p);
}
void* operator new(size_t size, const char* file, long line) {
cout<<file<<":"<<line<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p, const char* file, long line) {
cout<<file<<":"<<line<<endl;
free(p);
}
int n_;
};
void* operator new(size_t size) {
cout<<"global void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p) {
cout<<"global void operator delete(void* p)"<<endl;
free(p);
}
void* operator new[](size_t size) {
cout<<"global void* operator new[](size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete[](void* p) {
cout<<"global void operator delete[](void* p)"<<endl;
free(p);
}
int main(void) {
Test* p1 = new Test(10);//它是new operator=operator new + 构造函数的调用
delete p1;
char* str = new char[100];
delete[] str;
char chunk[10];
/*Test* p2 = new(chunk) Test(200);//placement new:是基于已有的地址来创建对象的，不会分配内存
cout<<p2->n_<<endl;
//Test* p3 = (Test*)chunk;
Test* p3 = reinterpret_cast<Test*>(chunk);
cout<<p3->n_<<endl;*/
return 0;
}
另外解决一下placement new还没重载造成下面的测试代码编译不过的问题：
#include <iostream>
using namespace std;
class Test {
public:
Test(int n): n_(n) {
cout<<"Test(int n): n_(n)"<<endl;
}
Test(const Test& other) {
cout<<"Test(const Test& other)"<<endl;
}
~Test() {
cout<<"~Test()"<<endl;
}
void* operator new(size_t size) {//重载operator new
cout<<"void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
/*void operator delete(void* p) {
cout<<"void operator delete(void* p)"<<endl;
free(p);
}*/
void operator delete(void* p, size_t size) {
cout<<"void operator delete(void* p, size_t size)"<<endl;
free(p);
}
void* operator new(size_t size, const char* file, long line) {
cout<<file<<":"<<line<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p, const char* file, long line) {
cout<<file<<":"<<line<<endl;
free(p);
}
void* operator new(size_t size, void* p) {
return p;
}
int n_;
};
void* operator new(size_t size) {
cout<<"global void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p) {
cout<<"global void operator delete(void* p)"<<endl;
free(p);
}
void* operator new[](size_t size) {
cout<<"global void* operator new[](size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete[](void* p) {
cout<<"global void operator delete[](void* p)"<<endl;
free(p);
}
int main(void) {
Test* p1 = new Test(10);//它是new operator=operator new + 构造函数的调用
delete p1;
char* str = new char[100];
delete[] str;
char chunk[10];
Test* p2 = new(chunk) Test(200);//placement new:是基于已有的地址来创建对象的，不会分配内存
cout<<p2->n_<<endl;
//Test* p3 = (Test*)chunk;
Test* p3 = reinterpret_cast<Test*>(chunk);
cout<<p3->n_<<endl;
return 0;
}
编译:
new和delete操作是需要匹配的，所以再重载一下delete方法：
#include <iostream>
using namespace std;
class Test {
public:
Test(int n): n_(n) {
cout<<"Test(int n): n_(n)"<<endl;
}
Test(const Test& other) {
cout<<"Test(const Test& other)"<<endl;
}
~Test() {
cout<<"~Test()"<<endl;
}
void* operator new(size_t size) {//重载operator new
cout<<"void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
/*void operator delete(void* p) {
cout<<"void operator delete(void* p)"<<endl;
free(p);
}*/
void operator delete(void* p, size_t size) {
cout<<"void operator delete(void* p, size_t size)"<<endl;
free(p);
}
void* operator new(size_t size, const char* file, long line) {
cout<<file<<":"<<line<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p, const char* file, long line) {
cout<<file<<":"<<line<<endl;
free(p);
}
void* operator new(size_t size, void* p) {
return p;
}
void operator delete(void*, void* p) {//关于它的函数原形可能通过debug内部跟踪得到
}
int n_;
};
void* operator new(size_t size) {
cout<<"global void* operator new(size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete(void* p) {
cout<<"global void operator delete(void* p)"<<endl;
free(p);
}
void* operator new[](size_t size) {
cout<<"global void* operator new[](size_t size)"<<endl;
void* p = malloc(size);
return p;
}
void operator delete[](void* p) {
cout<<"global void operator delete[](void* p)"<<endl;
free(p);
}
int main(void) {
Test* p1 = new Test(10);//它是new operator=operator new + 构造函数的调用
delete p1;
char* str = new char[100];
delete[] str;
char chunk[10];
Test* p2 = new(chunk) Test(200);//placement new:是基于已有的地址来创建对象的，不会分配内存
cout<<p2->n_<<endl;
//Test* p3 = (Test*)chunk;
Test* p3 = reinterpret_cast<Test*>(chunk);
cout<<p3->n_<<endl;
return 0;
}
再次编译运行：
修改代码如下:
再次编译运行，看这回构造与虚构是否匹配了：
好了，解决了placement new编译通过的问题之后，则下面来使用一下带多个参数的operator new的重载方法，如下：
下面来看下结果：
照理应该是调用与之匹配的它：
具体原因这里也不太清楚，反正如果不重写这个delete会给出警告，这个待之后再做出考证。对于上面这种写法其实可以定义成宏，如下：
