急求C++重载函数试验

#include <stringh>

#include <stdioh>

//声明数据结构

struct SFraction

{

int fz;

int fm;

};

//声明函数

int min(int, int);

float min(float, float);

int min(const int , int); //传入数组首地址到函数中时,一定要将该数组的长度一起传进去,否则到里面将会不知道该数组下标上限

int add(int, int);

//相加两字符串的函数一般定义为 char add(char _Dest,const char _Source),如同系统定义的strcat函数一样,

//目标字符串一般一char 类型传递进去并把相加的结果保存在_Dest中,因为要返回为char ,

//如果是在函数内部定义一个新的字符串来保存相加的结果的话,函数返回时会被清空

char add(char , const char );

//此函数第一个参数不能用const传递,原因同于两字符串相加的函数一样

SFraction add(SFraction &, const SFraction &);

int _tmain(int argc, _TCHAR argv[])

{

printf("4和3小值为:%d\n",min(4,3));

printf("43和58小值为:%f\n",min((float)(43),(float)(58)));

int arr[] = { 3,2,7,9,8,13 };

printf("arr数组中最小的数为:%d\n",min(arr,sizeof(arr)/sizeof(int)));

printf("5和8相加结果为:%d\n",add(5,8));

char Dest[100] = "I can help you! ";

char Source[20] = "Oh,thank you!";

printf("两字符串相加结果:%s\n",add(Dest,Source));

SFraction a,b,c;

afz = 3;

afm = 5;

bfz = 4;

bfm = 6;

c = add(a,b);

printf("3/4和4/6相加结果为:%d/%d\n",cfz,cfm);

getchar();

return 0;

}

//函数实现

int min(int a, int b)

{

if ( a < b )

{

return a;

}

else

{

return b;

}

}

float min(float a, float b)

{

if ( a < b )

{

return a;

}

else

{

return b;

}

}

int min(const int Arr,int Size)//传入数组首地址到函数中时,一定要将该数组的长度一起传进去,否则到里面将会不知道该数组下标上限

{

int theMin = Arr[0];

for ( int i = 1 ; i < Size ; i++ )

{

if ( theMin > Arr[i] )

{

theMin = Arr[i];

}

}

return theMin;

}

int add(int a, int b)

{

return a+b;

}

//相加两字符串的函数一般定义为 char add(char _Dest,const char _Source),如同系统定义的strcat函数一样,

//目标字符串一般一char 类型传递进去并把相加的结果保存在_Dest中,因为要返回为char ,

//如果是在函数内部定义一个新的字符串来保存相加的结果的话,函数返回时会被清空

char add(char a, const char b)

{

return strcat(a,b);

}

//此函数第一个参数不能用const传递,原因同于两字符串相加的函数一样

SFraction add(SFraction &a, const SFraction &b)

{

//分数相加先"通分"然后分子相加

int tmpFM = afm bfm;

int tmpFZofa = afz bfm;

int tmpFZofb = bfz afm;

afz = tmpFZofa+tmpFZofb;

afm = tmpFM;

return a;

}

滥用using namespace std的后果。

随便引入命名空间虽然可以简化代码编写，但是会造成命名空间污染，从而有冲突的风险。

你这个问题的本质很简单，std命名空间中原来就有一个函数名叫swap，因为它放在std命名空间内，本来是不干扰你的程序的。

但是你通过using namespace std引入了std命名空间，而你自己恰恰也定义了一个swap，两个函数名字相同。结果就造成函数名字冲突了。编译器看到两个同名、同参数定义的泛型函数，无法决定该调用哪一个，于是就报错。

解决方法有两种，要么去掉using namespace std;，然后把cout改为std::cout，endl改为std::endl，像这样：

#include<iostream>

template <typename Any>

void swap(Any &a,Any &b);

int main()

{

int i=1;

int j=2;

swap(i, j);

std::cout<<i<<j<<std::endl;

return 0;

}

template <typename Any>

void swap(Any &a,Any &b)

{

Any temp;

temp=a;

a=b;

b=temp;

}

要么就自己另外建立一个命名空间（比如myspace），然后把你自己写的那个函数扔进去，像这样：

#include<iostream>

using namespace std;

namespace myspace

{

template <typename Any>

void swap(Any &a,Any &b)

{

Any temp;

temp=a;

a=b;

b=temp;

}

}

int main()

{

int i=1;

int j=2;

myspace::swap(i, j); //指明调用自己写的swap

cout<<i<<j<<endl;

return 0;

}

这样就不会冲突了。

1、运算符重载不改变 *** 作符原先的优先级、结合性和 *** 作数数目，++是单目 *** 作符，所以1不会成立的。

你有这样的问题大概是因为双目 *** 作符比如，可以有xoperator（y）这种写法吧？ 但是这个不改变是二目 *** 作符的事实。C++规定：双目 *** 作符重载作为成员函数时只能有一个形参，调用方为左 *** 作数，形参为右 *** 作数。所以xoperator（y）等价于xy。

2、重载的是后置++。后置++重载作为成员函数时跟你说的一样，就只有一个int形参且该形参只起标志作用，在函数体实现不会用到；而作为友元函数时则是写成了双目的形式：

operator++（class ,int），这个跟双目运算符重载为成员函数时单形参否则双形参是一个道理的。换句话说，在重载的时候你可以把后置++看做是双目运算符，只是右 *** 作数只是起与前置区分的标识作用而已。

注意你定义的函数实现里面没有说明函数参数的类型。返回值类型注意一下，直接看我修改的代码。

using namespace std;

int area(int r);

int area(int a,int b);

float area(float c);

int perime(int r);

int perime(int a,int b);

float perime(float c);

int main()

{

cout<<"输入圆的半径"<<endl<<"输入长方形的长宽"<<endl<<"输入正方形的边长"<<endl;

int r,a,b,c;

cin>>r>>a>>b>>c;

cout<<area(r)<<endl;

cout<<perime(r)<<endl;

cout<<area(a, b)<<endl;

cout<<perime(a, b)<<endl;

cout<<area(c)<<endl;

cout<<perime(c)<<endl;

return 0;

}

int area(int r)

{

return 314rr;

}

int perime(int r)

{

return 2314r;

}

int area(int a, int b)

{

return ab;

}

int perime(int a,int b)

{

return 2(a+b);

}

float area(float c)

{

return cc;

}

float perime(float c)

{

return 4c;

}

一。重载就是多个方法使用一个方法名，但是参数的个数或类型不同，但他们的作用一般是相同的 。

二。可以通过传递不同的参数实现相同的效果。

三。发生在两个或者是更多的函数具有相同的名字的情况下。