运算符重载（二）

String类实现

• []运算符重载
  
  
  

• +运算符重载
  
  
  
  

• +=运算符重载
  
  

• <<运算符重载

  • c++的I/O流库的一个重要特性就是能够支持新的数据类型的输出和输入
  • 用户可以通过对插入符（<<）和提取符（>>）进行重载来支持新的数据类型
  • 流运算符的重载只能使用友元函数进行重载
  • 问题：为什么一定要使用友元函数进行重载？
  • friend istream& operator>>(istream&,类类型&);
    
    

• 运算符重载

  • friend ostream& operator<<(ostream&,const 类类型&);
    
    

类型转换运算符

• 必须是成员函数，不能是友元函数
• 没有参数（操作数是什么呢？）
• 不能指定返回类型（其实已经指定了）
• 函数原型：opertor类型名（）；
  
  
  

->运算符

#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()
{
	DB db;
	db->Open();
	db->Query();
	db->Close();
	return 0; 
}

operator new、operator delete

• 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;
		}
		int n_;
};
int main()
{
	Test* p1 = new Test(100);//new operator = operator new + 构造函数的调用
	
	//以下代码为 placement new,不分配内存 
	char chunk[10];
	Test* p2 = new(chunk) Test(200);//operator new(size_t,void *_Where)
	cout<<p2->n_<<endl;
	Test* p3 = (Test*)chunk;//等价于Test* p3 = reinterpret_cast<Test*>(chunk); 
	cout << p3->n_ <<endl;
	return 0;
}

• 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,lone 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)

#include <iostream>
#include <stdlib.h>
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)
		{
			cout<<"void* operator new(size_t size)"<<endl;
			void* p = malloc(size);
			return p;
		}
		/*//与底下的delete效果是一样的 
		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()
{
	Test* p1 = new Test(100);//new operator = operator new + 构造函数的调用
	delete p1;
	char* str = new char[100];
	delete[] str;
	
	//以下代码为 placement new,不分配内存 + 构造函数的调用 
	char chunk[10];
	Test* p2 = new(chunk) Test(200);//operator new(size_t,void *_Where)
	cout<<p2->n_<<endl;
	p2->~Test();//显示调用析构函数释放内存 
	Test* p3 = (Test*)chunk;//等价于Test* p3 = reinterpret_cast<Test*>(chunk); 
	cout << p3->n_ <<endl;
	Test* p4 = new(__FILE__,__LINE__)Test(300);
	delete p4;
	return 0;
}