person.h
#include <string.h>
#include <iostream>
#include <malloc.h>
using namespace std;
#ifndef _person
#define _person
class person{
private: //成员变量
int id;
char * name;
public: //函数
void printMsg();
void setId(int id);
void setName(char * name);
int getNameLen();
public: //构造函数
explicit person();
explicit person(int id, char * name);
public: //拷贝构造函数
person(person& temp){
this->id = temp.id;
this->name = new char[20];
strcpy(this->name, temp.name);
}
public: //运算符重载
void operator=(person& temp){
this->id = temp.id;
this->name = new char[20];
strcpy(this->name, temp.name);
}
//& 引用传递
person operator+(person& temp){
person newPerson;
newPerson.setId(this->id + temp.id);
newPerson.setName(this->name);
return newPerson;
}
//转换成int
//类型转换 1、不能指定返回类型 2、无参
// 显示转换 运算符重载 不能定义为全局
//--》 int i = (int)onePerson;
operator int(){
return this->id;
}
//前置++
person& operator++(){
this->id++;
return *this;
}
//后置++ 先赋值后加
person operator++(int){
person newPerson=*this;
this->id++;
return newPerson;
}
//下标取字符
char operator[](int temp){
//cout<<strlen(this->name)<<endl;
if(this->name==NULL) return '\0';
if(temp>=strlen(this->name)) return '\0';
return this->name[temp];
}
/*
new 运算符重载
1、必须是static [注意：此处可以不加static 编译器都认为是静态的运算符重载]
2、返回值必须是 void*
3、可以带多个参数， 但第一个参数必须是size_t
[typedef unsigned int size_t;]
*/
void* operator new(size_t){
void* newPerson = malloc(sizeof(person));
return newPerson;
}
void* operator new[](size_t temp){
cout<<temp<<endl;
void* newPerson = malloc(sizeof(person));
return newPerson;
}
/*
delete运算符重载
1、必须是static [注意：此处可以不加static 编译器都认为是静态的运算符重载]
2、必须返回void类型
3、可以带多个参数
3.1、第一个参数必须释放内存的地址 void*
3.2、如果指定了第二个参数，则必须是 size_t 类型
*/
void operator delete(void* temp, size_t t){
if(temp!=NULL){
free(temp);
temp=NULL;
}
}
public: //析构函数
~person();
public: //友元
//friend person operator+(person& temp1, person& temp2);
friend ostream& operator<<(ostream&, person&);
friend void operator>>(istream&, person&);
};
#endif _person
person.cpp
#include "person.h"
#include <iostream>
using namespace std;
#include <string.h>
/*-----------------------
构造函数
------------------------*/
person::person(){
this->id = 0;
this->name = new char[20];
strcpy(this->name, "itao");
}
person::person(int id, char * name){
this->id = id;
this->name = new char[20];
strcpy(this->name, name);
}
/*-----------------------
常用函数
------------------------*/
void person::printMsg(){
if(this->name!=NULL)
cout<<"id="<<this->id<<" name="<<this->name<<endl;
else
cout<<"id="<<this->id<<endl;
}
void person::setId(int id){
this->id = id;
}
void person::setName(char * name){
this->name = new char[20];
strcpy(this->name, name);
}
int person::getNameLen(){
return strlen(this->name);
}
/*-----------------------
析构函数
------------------------*/
person::~person(){
if(this->name!=NULL){
delete this->name;
this->name = NULL;
}
}
operator.cpp
#include <iostream>
#include <string.h>
using namespace std;
#include <Afxwin.h>
#include "person.h"
//全局 运算符重载 在person类中声明为友元 才有访问成员变量的权限
/*
person operator+(person& temp1, person& temp2){
person newPerson;
newPerson.id = temp1.id + temp2.id;
newPerson.setName(temp1.name);
return newPerson;
}
*/
//输出 运算符重载 需在类中声明为 友元
ostream& operator<<(ostream& out, person& temp){
out<<temp.id<<endl;
out<<temp.name<<endl;
return out;
}
//输入 运算符重载 需在类中声明为 友元
void operator>>(istream& in, person& temp){
cout<<"please input the person's id:";
in>>temp.id;
cout<<"please input the person's name:";
in>>temp.name;
}
int main(){
/*
new 运算符重载
*/
person* onePerson = new person;
cout<<sizeof *onePerson<<endl;
onePerson->printMsg();
delete onePerson; //先调用析构函数 再调用 delete运算符重载
//cout<<onePerson<<endl;
return 0;
}
int test5(){
person onePerson(21, "qintangtao");
int i;
int len = onePerson.getNameLen();
for(i=0; i<len; i++){
cout<<onePerson[i]<<endl;
}
return 0;
}
int test4(){
person onePerson(4, "itao");
person otherPerson=onePerson++; //先赋值后加
cout<<onePerson; //5
cout<<otherPerson; //4
return 0;
}
int test3(){
person onePerson(4, "heihei");
//int i = (int)onePerson; //用到了运算符重载
//cout<<"i="<<i<<endl;
/*
cout<<onePerson<<endl;
//等价
::operator<<(cout, onePerson).operator<<(endl);
*/
cin>>onePerson;
cout<<onePerson;
return 0;
}
int test2(){
person onePerson(1, "itao");
person twoPerson(2, "love");
person threePerson;
threePerson = onePerson + twoPerson; //注意此处 返回的是临时变量 在赋值时 调用的是拷贝构造函数 而不是 赋值运算符重载
//等价于 全局函数 [注意：全局函数和局部函数重名 只能取其中一个]
//threePerson = ::operator+(onePerson, twoPerson);
threePerson.printMsg();
person otherPerson = onePerson;
return 0;
}
int test1(){
/*string a("Hello Word");
a+=" itao";
cout<<a.c_str()<<endl;*/
CPoint a(100, 100);
CPoint b(200, 200);
CPoint c;
/*c.x = a.x + b.x;
c.y = a.y + b.y;
*/
c = a + b;
cout<<c.x<<endl<<c.y<<endl;
return 0;
}
