运算符重载允许把标准运算符（如+、—、*、/、<、>等）应用于自定义数据类型的对象。直观自然，可以提高程序的可读性，体现了C++的可扩充性。运算符重载仅仅只是语法上的方便，它是另一种函数调用的方式。运算符重载，本质上是函数重载，所以不要滥用重载、因为它只是语法上的方便，所以只有在涉及的代码更容易写、尤其是更易读时才有必要重载。
运算符重载有两种方式，一种是重载为成员函数，函数原型如下。
返回值类型 operator 运算符(参数表);
还可以重载为友元函数的方式，函数原型如下。
friend 返回值类型 operator 运算符(参数表);
可重载的运算符有一元运算符和二元运算符，一元运算符有一个参数，二元运算符有两个参数，对应于函数调用的参数。重载为成员函数时，this指针默认为第一个参数，而重载为友元时需要显示表示所有参数。请看下面这个例子。
#include <iostream>
using namespace std;
class Integer{
friend ostream& operator<<(ostream& out, const Integer& i);
public:
Integer(int val):val_(val){}
Integer& operator++(){
val_++;
return *this;
}
Integer operator++(int i){
Integer temp(val_);
val_++;
return temp;
}
operator int(){
return val_;
}
private:
int val_;
};
ostream& operator<<(ostream& out, const Integer& i){
out<<i.val_;
return out;
}
int main(int argc, char const *argv[])
{
Integer i(2);
cout<<i++<<endl; /* cout<<i.operator++()<<endl; */
cout<<++i<<endl; /* cout<<i.operator++(0)<<endl; */
int a = 1 + i;
cout<<a<<endl;
system("pause");
return 0;
}
这个例子想说明的是，第一，可以手动调用重载的运算符；第二，因为++，--运算符分为前置和后置，所以在重载运算符的时候，后置的++，--需要增加一个int参数，这个参数没什么用，只是为了区分是前置还是后置。并且，可以看出，由于后置的++，--为了满足语义需要创建一个临时对象，所以用前置++，--的效率要高一点。
此外，运算符重载有以下的注意点。
- 运算符重载不允许发明新的运算符。
- 不能改变运算符操作对象的个数。
- 运算符被重载后，其优先级和结合性不会改变。
- 以下运算符不能重载：::(作用域解析运算符)，?:（ 条件运算符），.（直接成员访问运算符），.*（类成员指针引用的运算符 ），sizeof（sizeof运算符 ）。
- 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
- 以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。
- 类型转换运算符只能以成员函数方式重载，没有参数，不能指定返回类型，函数原型如下。
operator 类型名();
- 流运算符只能以友元的方式重载。
运算符重载例子，String类的简单实现
String类需要重载的运算符为，=运算符，[]运算符重载，+运算符重载，+=运算符重载，<<运算符重载， > >运算符重载。下面是具体的代码。
#include <iostream>
#include <exception>
#include <string.h>
using namespace std;
class String{
friend ostream& operator<<(ostream& os, const String& s);
friend istream& operator>>(istream& is, const String& s);
friend String operator+(const String& s1, const String& s2);
public:
String(const char *str = ""){
str_ = new char[strlen(str) + 1];
strcpy(str_,str);
}
~String(){
delete[] str_;
}
char *str_;
String(const String& other){
delete[] str_;
str_ = new char[strlen(other.str_)+1];
strcpy(str_,other.str_);
}
String& operator=(const String& other){
if(this != &other){
delete[] str_;
str_ = new char[strlen(other.str_) + 1];
strcpy(str_,other.str_);
}
return *this;
}
String& operator=(const char *s){
delete[] str_;
str_ = new char[strlen(s) + 1];
strcpy(str_,s);
return *this;
}
String& operator+=(const String& other){
char *str = new char[strlen(str_) + strlen(other.str_) + 1];
strcpy(str,str_);
strcat(str,other.str_);
delete[] str_;
str_ = str;
return *this;
}
const char& operator[](int index) const{
if(index >= strlen(str_)){
throw out_of_range("index is out of range");
}
return str_[index];
}
char& operator[](int index){
const char& c = (static_cast<const String&>(*this))[index];
return const_cast<char &>(c);
}
};
ostream& operator<<(ostream& os, const String& s){
os<<s.str_;
return os;
}
istream& operator>>(istream& is, String& s){
char temp[1024];
is>>temp;
s = temp;
return is;
}
String operator+(const String& s1, const String& s2){
char * str = new char[strlen(s1.str_) + strlen(s2.str_) + 1];
strcpy(str,s1.str_);
strcat(str,s2.str_);
return String(str);
}
int main(int argc, char const *argv[])
{
String s1,s2;
cin>>s1>>s2;
s1 += s2;
for(int i=0;i<strlen(s1.str_);i++){
cout<<s1[i];
}
cout<<endl;
String s3 = s1 + "!!!";
cout<<s3;
system("pause");
return 0;
}
重载->运算符
这个运算符的重载有点奇怪，先看看下面的代码。
#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;}
};
class DBHelper{
public:
DBHelper(){
db_ = new DB();
}
~DBHelper(){
delete db_;
}
DB* operator->(){
return db_;
}
private:
DB* db_;
};
int main(int argc, char const *argv[])
{
DBHelper db;
db->open();
db->close();
return 0;
}
虽然->运算符返回了一个DB指针，但是它的后面可以直接跟上一个函数调用，这让我感觉有点奇怪。
重载operator new、operator delete
先看下面一段代码。
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char const *argv[])
{
char buf[1024];
string *str = new(buf) string("hello");
cout<<&buf<<" "<<str<<endl;
str->~basic_string();
return 0;
}
一个new操作符执行的操作是，operator new + 调用构造函数。operator new的主要作用是分配内存，这个操作符是可以重载的，并且有几种形式。上面的这种用法是placement new，不分配内存，而是指定一个内存。从上面的代码可以看出，在这种情况下，需要手动调用析构函数，不然构造函数中分配的内存无法释放。operator new和operator delete可以重载为局部的，也可以重载为全局的。我们可以通过重载一个全局的operator new和delete来实现一个简单的内存追踪器。内存跟踪器的大体思路是，我们重载全局的operator new和delete，自己实现内存的分配，然后使用一个全局的map，每次有内存分配，就添加一条记录；每次有释放内存，就去掉对应的记录。这个有点像模板设计模式，通过自定义一些功能来实现一些额外的功能。下面是具体的代码。
#include <map>
#include <iostream>
class Tracer{
friend class Lock;
public:
bool ready_;
Tracer():lockCount_(0),ready_(true){}
~Tracer(){
ready_ = false;
dump();
}
void add(void *p,const char *file, unsigned int line){
if(lockCount_ > 0){
return;
}
Tracer::Lock lock(*this);
entryMap_.insert(std::make_pair(p,Entry(file,line)));
}
void remove(void *p){
if(lockCount_ > 0){
return;
}
Tracer::Lock lock(*this);
std::map<void*,Entry> :: const_iterator it = entryMap_.find(p);
if(it != entryMap_.end()){
entryMap_.erase(it);
}
}
void dump(){
if(entryMap_.size() > 0){
std::cout << "-----------------------Memory leak(s)-----------------------" << std::endl;
std::map<void*,Entry>::const_iterator it;
for(it = entryMap_.begin();it != entryMap_.end(); ++it){
std::cout << "0x" << std::hex << it->first << ":"
<< it->second.file_ << " line: " << std::dec << it->second.line_ << std::endl;
}
std::cout<<std::endl;
}
}
private:
class Entry{
public:
const char *file_;
unsigned int line_;
Entry(const char *file = NULL, unsigned int line = 0):file_(file),line_(line){}
};
class Lock{
private:
Tracer& tracer_;
public:
Lock(Tracer& tracer):tracer_(tracer){
tracer_.lock();
}
~Lock(){
tracer_.unlock();
}
};
unsigned int lockCount_;
std::map<void*,Entry> entryMap_;
void lock(){
lockCount_++;
}
void unlock(){
lockCount_--;
}
};
Tracer gTracer;
void* operator new(size_t size, const char * file, unsigned int line){
if(size == 0){
size = 1;
}
void *p = malloc(size);
if(gTracer.ready_ )
gTracer.add(p,file,line);
return p;
}
void operator delete(void *p, const char*, unsigned int line){
if(gTracer.ready_ )
gTracer.remove(p);
free(p);
}
void* operator new(size_t size){
if(size == 0){
size = 1;
}
void *p = malloc(size);
if(gTracer.ready_ )
gTracer.add(p,"?",0);
return p;
}
void operator delete(void *p){
if(gTracer.ready_ )
gTracer.remove(p);
free(p);
}
void* operator new[](size_t size){
if(size == 0){
size = 1;
}
void *p = malloc(size);
if(gTracer.ready_ )
gTracer.add(p,"?",0);
return p;
}
void operator delete[](void *p){
if(gTracer.ready_ )
gTracer.remove(p);
free(p);
}
void* operator new[](size_t size, const char * file, unsigned int line){
if(size == 0){
size = 1;
}
void *p = malloc(size);
if(gTracer.ready_ )
gTracer.add(p,file,line);
return p;
}
void operator delete[](void *p, const char * file, unsigned int line){
if(gTracer.ready_ )
gTracer.remove(p);
free(p);
}
#define new new(__FILE__,__LINE__)
在构造函数中调用构造函数
class A{
public:
A(int val):val_(val){
cout<<val<<endl;
}
A(){
new(this) A(10); //如果使用A(10)只会在栈上创建一个临时对象
}
int val_;
};
网友评论