重载为类的成员函数

运算符重载的目的：要使程序员自己定义的类所实例的对象，能像int，char等基础类型进行加减乘除、赋值、输入输出等运算。原则：用成员函数重载一元及与赋值有关的运算符，其中“=、()、[]、->、->”必须用成员函数重载；用全局函数重载与赋值无关且不是必须用成员函数重载的二元运算符。

例如：

class Fraction

{

friend istream& operator>>(istream&,Fraction&);//全局函数重载>>

friend ostream& operator<<(ostream&,const Fraction&);//全局函数重载<<

friend Fraction operator!(const Fraction&);//全局函数重载一元运算符

//全局函数重载二元运算符

friend Fraction operator+(const Fraction&,const Fraction&);

friend Fraction& operator++(Fraction&);//全局函数重载前缀++运算符

friend Fraction operator++(Fraction&,int);//全局函数重载后缀++运算符

public:

Fraction(int=0,int=1);//默认构造函数

Fraction(double);//根据double构造Fraction

void set(int,int);

Fraction operator-()const;//成员函数重载一元运算符

Fraction operator-(const Fraction&)const;//成员函数重载二元运算符

operator double()const;//类型转换

Fraction& operator--();//成员函数重载前缀--算符

Fraction operator--(int);//成员函数重载后缀--算符

private:

int molecular;//分子

int denominator;//分母

static int gcd(int,int);//求两个整数的最大公约数

};

//成员函数重载一元运算符

Fraction Fraction::operator-()const

{

return Fraction(-molecular,denominator);

}

//成员函数重载二元运算符

Fraction Fraction::operator-(const Fraction& other)const

{

int m=otherdenominatormolecular-denominatorothermolecular;

int d=denominatorotherdenominator;

return Fraction(m,d);

}

//全局函数重载>>

istream& operator>>(istream& in,Fraction& fraction)

{

int m=0;

int d=1;

in>>m;

inignore();

in>>d;

fractionset(m,d);

return in;

}

//全局函数重载<<

ostream& operator<<(ostream& out,const Fraction& fraction)

{

if(double(fraction)<0)

out<<"-";

out<<fabs(fractionmolecular);

if(fractionmolecular!=0&&fractiondenominator!=1)

out<<"/"<<fabs(fractiondenominator);

return out;

}

你的程序例子不太标准，不易于理解。推荐《C++程序设计实例教程》刘振宇 东软电子出版社 讲得很清晰透彻，非常适于初学者。学习C++，基础很重要！

如果有需要的话，请把邮箱留给我，我有电子书。

int main(){     int a,b;     int c,d,e;     cout<<"请输入两个整数："<<endl;     cin>>a>>b;     sort(a,b);     cout<<"排序之后："<<a<<" "<<b<<" "<<endl;     cout<<"请输入三个整数：

<<endl;     cin>>c>>d>>e;     sort(c,d,e);     cout<<"排序之后："<<c<<" "<<d<<" "<<e<<" "<<endl;    getchar();    getchar();     return 0;}

public void sort ( int a, int b)

{

ConsoleWriteLine("两整数从小到大依次为{0}、{1}",a<=ba:b,a>ba:b);

}

public void sort(double a, double b,double c)

{

double max ,mid,min;

if(a-b>=00)

{max=a; min=b;}

else

{max=b;min=a;}

if(max-c<00)

{ mid=max; max=c;}

else if(min-c>00)

{ mid=min; min=c;}

else

mid =c;

ConsoleWriteLine("三个实数从小到大依次为{0}、{1}、{2}",min,mid,max);

}

扩展资料：

C++的这种编程机制给编程者极大的方便，不需要为功能相似、参数不同的函数选用不同的函数名，也增强了程序的可读性。

C++运算符重载的相关规定如下：

（1）不能改变运算符的优先级；

（2）不能改变运算符的结合型；

（3）默认参数不能和重载的运算符一起使用；

（4）不能改变运算符的 *** 作数的个数；

-重在函数

//用同名重载函数实现， 三种数据类型数组的排序

//VC2005 下编译测试通过

#include<iostream>

void Sort( int a[], int len )

{

int k,t;

for ( int i=0; i < len-1; i++ )

{

k=i;

for ( int j=i+1; j < len; j++ )

{

if ( a[k] > a[j] )

{

k=j;

}

}

if ( k!=i)

{

t=a[i];

a[i]=a[k];

a[k]=t;

}

}

}

void Sort( double a[], int len )

{

double t;

int k;

for ( int i=0; i < len-1; i++ )

{

k=i;

for ( int j=i+1; j < len; j++ )

{

if ( a[k] > a[j] )

{

k=j;

}

}

if ( k!=i)

{

t=a[i];

a[i]=a[k];

a[k]=t;

}

}

}

void Sort( float a[], int len )

{

float t;

int k;

for ( int i=0; i < len-1; i++ )

{

k=i;

for ( int j=i+1; j < len; j++ )

{

if ( a[k]>a[j] )

{

k=j;

}

}

if ( k!=i)

{

t=a[i];

a[i]=a[k];

a[k]=t;

}

}

}

int main()

{

int a[10]= { 100, 98, 6, 12, 21, 20, 78, 65, 78, 54 };

float f[10]={ 764, 324, 564, 90, 12, 1, 2, 34, 454, 231 };

double d[10]={ 234, 1, 2, 22, 212, 345, 5, 6, 21, 11};

Sort( a, 10);

Sort( f, 10);

Sort( d, 10);

//输出排序后的数组

for ( int i=0; i<10; i++ )

{

std::cout<< a[i]<<" ";

}

std::cout<< "\n";

for ( int i=0; i < 10; i++ )

{

std::cout<< f[i] << " ";

}

std::cout<<std::endl;

for ( int i=0; i < 10; i++ )

{

std::cout<< d[i] << " ";

}

return 0;

}

//PS: 楼上说得不错，如果想简便当然是模板实现比较方便, 但LZ要求用函数重

//载实现， 呵呵，所以楼上的虽然排序结果正确，却不符合楼主的题意！呵呵