//--《C++捷径教程》读书笔记--Chapter 13--运算符的重载（完结）
//--Chapter 13--运算符的重载
//--04/13/2006 Thurs.
//--Computer Lab
//--Liwei
//--程序＃1 说明成员函数重载运算符
#include <iostream>
using namespace std;
class three_d{
int x,y,z;
public:
three_d() { x=y=z=0; }
three_d( int i,int j,int k ) { x=i; y=j; z=k; }
three_d operator+(three_d op2);
three_d operator=(three_d op2);
void show();
};
three_d three_d::operator +(three_d op2)
{
three_d temp;
temp.x=x+op2.x;
temp.y=y+op2.y;
temp.z=z+op2.z;
return temp;
}
three_d three_d::operator =(three_d op2)
{
x=op2.x;
y=op2.y;
z=op2.z;
return *this;
}
void three_d::show()
{
cout<<x<<' ';
cout<<y<<' ';
cout<<z<<'/n';
}
int main()
{
three_d a(1,2,3),b(10,10,10),c;
a.show();
b.show();
c.show();
c=a+b;
c.show();
c=a+b+c;
c.show();
c=b=a;
c.show();
b.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃2 说明成员函数重载运算符
#include <iostream>
using namespace std;
class three_d{
int x,y,z;
public:
three_d() { x=y=z=0; }
three_d( int i,int j,int k ) { x=i; y=j; z=k; }
three_d operator+(three_d op2);
three_d operator=(three_d op2);
three_d operator++();
void show();
};
three_d three_d::operator +(three_d op2)
{
three_d temp;
temp.x=x+op2.x;
temp.y=y+op2.y;
temp.z=z+op2.z;
return temp;
}
three_d three_d::operator =(three_d op2)
{
x=op2.x;
y=op2.y;
z=op2.z;
return *this;
}
three_d three_d::operator ++()
{
x++;
y++;
z++;
return *this;
}
void three_d::show()
{
cout<<x<<' ';
cout<<y<<' ';
cout<<z<<'/n';
}
int main()
{
three_d a(1,2,3),b(10,10,10),c;
a.show();
b.show();
//c.show();
c=a+b;
c.show();
c=a+b+c;
c.show();
c=b=a;
c.show();
b.show();
++c();
c.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃3 说明成员函数重载运算符
#include <iostream>
using namespace std;
class three_d{
int x,y,z;
public:
three_d() { x=y=z=0; }
three_d( int i,int j,int k ) { x=i; y=j; z=k; }
three_d operator+(three_d op2);
three_d operator=(three_d op2);
three_d operator++();
three_d operator++(int notused);
three_d operator--();
three_d operator--(int notused);
void show();
};
three_d three_d::operator +(three_d op2)
{
three_d temp;
temp.x=x+op2.x;
temp.y=y+op2.y;
temp.z=z+op2.z;
return temp;
}
three_d three_d::operator =(three_d op2)
{
x=op2.x;
y=op2.y;
z=op2.z;
return *this;
}
three_d three_d::operator ++()
{
x++;
y++;
z++;
return *this;
}
three_d three_d::operator ++(int notused)
{
three_d temp=*this;
x++;
y++;
z++;
return temp;
}
three_d three_d::operator --()
{
x--;
y--;
z--;
return *this;
}
three_d three_d::operator --(int notused)
{
three_d temp=*this;
x--;
y--;
z--;
return temp;
}
void three_d::show()
{
cout<<x<<',';
cout<<y<<',';
cout<<z<<'/n';
}
int main()
{
three_d a(1,2,3),b(10,10,10),c;
a.show();
b.show();
//c.show();
c=a+b;
c.show();
c=a+b+c;
c.show();
c=b=a;
c.show();
b.show();
++c;
c.show();
c++;
c.show();
cout<<"====================/n";
a=++c;
a.show();
c.show();
a=c++;
a.show();
c.show();
cout<<"====================/n";
b.show();
a=--b;
a.show();
b.show();
cout<<"====================/n";
b.show();
a=b--;
a.show();
b.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃4 说明友元函数重载运算符
#include <iostream>
using namespace std;
class three_d{
int x,y,z;
public:
three_d() { x=y=z=0; }
three_d( int i,int j,int k ) { x=i; y=j; z=k; }
friend three_d operator +(three_d op1,three_d op2);
three_d operator=(three_d op2);
void show();
};
three_d operator +(three_d op1,three_d op2)
{
three_d temp;
temp.x=op1.x+op2.x;
temp.y=op1.y+op2.y;
temp.z=op1.z+op2.z;
return temp;
}
three_d three_d::operator =(three_d op2)
{
x=op2.x;
y=op2.y;
z=op2.z;
return *this;
}
void three_d::show()
{
cout<<x<<',';
cout<<y<<',';
cout<<z<<'/n';
}
int main()
{
three_d a(1,2,3),b(10,10,10),c;
a.show();
b.show();
// c=a+b;
c.show();
// c=a+b+c;
c.show();
c=b=a;
c.show();
b.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃5 说明友元函数重载运算符
#include <iostream>
using namespace std;
class CL{
public:
int count;
CL operator=(CL obj);
friend CL operator+(CL ob,int i);
friend CL operator+(int i,CL ob);
};
CL CL::operator =(CL obj)
{
count=obj.count;
return *this;
}
CL operator+(CL ob,int i)
{
CL temp;
temp.count=ob.count+i;
return temp;
}
CL operator+(int i,CL ob)
{
CL temp;
temp.count=ob.count+i;
return temp;
}
int main()
{
CL o;
o.count=10;
cout<<o.count<<" ";
o=10+o;
cout<<o.count<<" ";
o=o+12;
cout<<o.count;
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃6 说明友元函数重载运算符
#include <iostream>
using namespace std;
class three_d{
int x,y,z;
public:
three_d() { x=y=z=0; }
three_d( int i,int j,int k ) { x=i; y=j; z=k; }
friend three_d operator+(three_d op1,three_d op2);
three_d operator=(three_d op2);
friend three_d operator++(three_d &op1);
friend three_d operator++(three_d &op1, int notused);
void show();
};
three_d operator +(three_d op1,three_d op2)
{
three_d temp;
temp.x=op1.x+op2.x;
temp.y=op1.y+op2.y;
temp.z=op1.z+op2.z;
return temp;
}
three_d three_d::operator =(three_d op2)
{
x=op2.x;
y=op2.y;
z=op2.z;
return *this;
}
three_d operator++(three_d &op1)
{
op1.x++;
op1.y++;
op1.z++;
return op1;
}
three_d operator++(three_d &op1,int notused)
{
three_d temp=op1;
op1.x++;
op1.y++;
op1.z++;
return temp;
}
void three_d::show()
{
cout<<x<<',';
cout<<y<<',';
cout<<z<<'/n';
}
int main()
{
three_d a(1,2,3),b(10,10,10),c;
a.show();
b.show();
c=a+b;
c.show();
c=a+b+c;
c.show();
c=b=a;
c.show();
b.show();
++c;
c.show();
c++;
c.show();
a=++c;
a.show();
c.show();
a=c++;
a.show();
c.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃7 说明赋值运算
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class sample{
char *s;
public:
sample() { s=0; cout<<"Normal constructor./n"; }
sample(const sample &ob);
~sample() { if(s) delete []s; cout<<"Freeing s./n";}
void show() {cout<<s<<'/n';}
void set( char *str);
};
sample::sample(const sample &ob)
{
cout<<"Copy constructor./n";
s=new char[strlen(ob.s)+1];
strcpy(s, ob.s);
}
void sample::set(char *str)
{
s=new char[strlen(str)+1];
strcpy(s, str);
}
sample input()
{
char instr[80];
sample str;
cout<<"Enter a string: ";
cin>>instr;
str.set(instr);
return str;
}
int main()
{
sample ob;
ob=input();
ob.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃8 说明赋值运算
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class sample{
char *s;
public:
static int elye;
sample() { s=new char('/0'); cout<<"Normal constructor."; }
sample(const sample &ob);
~sample() { if(s) delete []s; cout<<"Freeing s./n";}
void show() {cout<<s<<'/n';}
void set( char *str);
sample operator=(sample &ob);
};
int elye=0;
sample::sample(const sample &ob)
{
cout<<"Copy constructor./n";
s=new char[strlen(ob.s)+1];
strcpy(s, ob.s);
}
void sample::set(char *str)
{
s=new char[strlen(str)+1];
strcpy(s, str);
}
sample sample::operator =(sample &ob)
{
if(strlen(ob.s)>strlen(s))
{
delete []s;
s=new char[strlen(ob.s)+1];
}
strcpy(s,ob.s);
return *this;
}
sample input()
{
char instr[80];
sample str;
cout<<"Enter a string: ";
cin>>instr;
str.set(instr);
return str;
}
int main()
{
sample ob;
ob=input();
ob.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃9 说明[]
#include <iostream>
using namespace std;
const int SIZE=3;
class atype{
int a[SIZE];
public:
atype()
{ register int i; for(i=0; i<SIZE;i++) a[i]=i; }
int operator[](int i) { return a[i];}
};
int main()
{
atype ob;
cout<<ob[2]<<endl;
cout<<ob.operator [](1)<<endl;
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃10 说明[]
#include <iostream>
using namespace std;
const int SIZE=30;
class atype{
int a[SIZE];
public:
atype()
{ register int i; for(i=0; i<SIZE;i++) a[i]=i; }
int &operator[](int i) { return a[i];}
};
int main()
{
atype ob;
cout<<ob[2]<<endl;
cout<<ob.operator [](2)<<endl;
cout<<"==============/n";
ob[2]=25;
cout<<ob[2]<<endl;
cout<<ob.operator [](2)<<endl;
cout<<"==============/n";
ob.operator [](2)=250;
cout<<ob[2]<<endl;
cout<<ob.operator [](2)<<endl;
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃11 说明[]，实现安全数组
#include <iostream>
using namespace std;
const int SIZE=3;
class atype{
int a[SIZE];
public:
atype()
{ register int i; for(i=0; i<SIZE;i++) a[i]=i; }
int &operator[](int i);
};
int &atype::operator [](int i)
{
if(i<0 || i>SIZE-1)
{
cout<<"/nIndex value of"<<i<<" is out of bounds./n";
exit(1);
}
return a[i];
}
int main()
{
atype ob;
cout<<ob[2]<<endl;
cout<<ob.operator [](2)<<endl;
cout<<"==============/n";
ob[2]=25;
cout<<ob[2]<<endl;
cout<<ob.operator [](2)<<endl;
cout<<"==============/n";
ob.operator [](2)=250;
cout<<ob[2]<<endl;
cout<<ob.operator [](2)<<endl;
ob[3]=444;
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃12 说明()
#include <iostream>
using namespace std;
class three_d{
int x,y,z;
public:
three_d() { x=y=z=0; }
three_d( int i,int j,int k ) { x=i; y=j; z=k; }
three_d operator()(int a,int b,int c);
void show();
};
three_d three_d::operator ()(int a,int b,int c)
{
three_d temp;
temp.x=x+a;
temp.y=y+b;
temp.z=z+c;
return temp;
}
void three_d::show()
{
cout<<x<<' ';
cout<<y<<' ';
cout<<z<<'/n';
}
int main()
{
three_d ob1(1,2,3),ob2;
ob2=ob1(10,11,12);
cout<<"ob1:";
ob1.show();
cout<<"ob2:";
ob2.show();
return 0;
}
//=================================================================//
// END //
//=================================================================//
//--程序＃13 说明字符串
#include <iostream>
#include <cstring>
using namespace std;
class str_type{
char string[80];
public:
str_type(char *str="") {strcpy(string,str);}
str_type operator+(str_type str);
str_type operator+(char *str);
str_type operator=(str_type str);
str_type operator=(char *str);
void show_str() { cout<<string;}
};
str_type str_type::operator +(str_type str)
{
str_type temp;
strcpy(temp.string, string);
strcat(temp.string, str.string);
return temp;
}
str_type str_type::operator +(char *str)
{
str_type temp;
strcpy(temp.string, string);
strcat(temp.string, str);
return temp;
}
//=====================================
str_type str_type::operator =(str_type str)
{
strcpy(string, str.string);
return *this;
}
str_type str_type::operator =(char *str)
{
str_type temp;
strcpy(string, str);
strcpy(temp.string, string);
return temp;
}
int main()
{
str_type a("Hello "), b("There"), c;
char *d="liwei";
c=a+b;
c.show_str();
cout<<'/n';
// b.show_str();
// a.show_str();
// cout<<'/n';
// c=a+d;
// c.show_str();
a="To program in because";
a.show_str();
cout<<'/n';
b=c="C++ is fun";
c=c+" "+a+" "+b;
c.show_str();
cout<<'/n';
cout<<"==============================/n";
cout<<"a:";
a.show_str();
cout<<"/nb:";
b.show_str();
cout<<"/nc:";
c.show_str();
cout<<"==============================/n";
cout<<endl;
b=c=a;
cout<<"b:";
b.show_str();
cout<<endl;
return 0;
}
//=================================================================//
// END //
//=================================================================//