上传新文件

Ch8函数探幽/函数重载/函数重载.cpp

+/*
+* 函数多态是C++在C语言的基础上新增的功能。
+默认参数让您能够使用不同数目的参数调用同一个函数，
+而函数多态（函数重载）让您能够使用多个同名的函数。
+
+
+
+术语“多态”指的是有多种形式，因此函数多态允许函数可以有多种形式。
+类似地，术语“函数重载”指的是可以有多个同名的函数，
+因此对名称进行了重载。
+这两个术语指的是同一回事，但我们通常使用函数重载。
+
+可以通过函数重载来设计一系列函数—它们完成相同的工作，
+但使用不同的参数列表。
+*/
+
+
+//重载函数就像是有多种含义的动词。
+/*
+* 例如，Piggy小姐可以在棒球场为家乡球队助威(root)，
+也可以在地里种植（root）菌类作物。
+根据上下文可以知道在每一种情况下，
+root 的含义是什么。
+同样，C++使用上下文来确定要使用的重载函数版本。
+*/
+
+
+//函数重载的关键是函数的参数列表
+//——也称为函数特征标（function signature)。
+/*
+* 如果两个函数的参数数目和类型相同，同时参数的排列顺序也相同，
+则它们的特征标相同，而变量名是无关紧要的。
+C++允许定义名称相同的函数，条件是它们的特征标不同。
+如果参数数目和/或参数类型不同，则特征标也不同。
+例如，可以定义一组原型如下的print()函数:
+*/
+
+void print(const char* str, int width);			//#1
+void print(double d, int width);				//#2
+void print(long l, int width);					//#3
+void print(int i, int width);					//#4
+void print(const char* str);					//#5
+
+
+
+//使用print()函数时，
+//编译器将根据所采取的用法使用有相应特征标的原型:
+print("Pancakes", 15);						//use #1
+print("Syrup");								//use #5
+print(1999.0, 10);							//use #2
+print(1999, 12);							//use #4
+print(1999L, 15);							//use #3
+
+/*
+* 例如，print("Pancakes",15)使用一个字符串和一个整数作为参数，
+这与#1原型匹配。使用被重载的函数时，
+需要在函数调用中使用正确的参数类型。例如，对于下面的语句:
+*/
+
+unsigned int year = 3210;
+print(year, 6);				//ambiguous call
+/*
+* print()调用与哪个原型匹配呢?它不与任何原型匹配!
+没有匹配的原型并不会自动停止使用其中的某个函数，
+因为C++将尝试使用标准类型转换强制进行匹配。
+如果#2原型是print()唯一的原型，
+则函数调用print(year，6)将把 year转换为double类型。
+但在上面的代码中，有3个将数字作为第一个参数的原型，
+因此有3种转换year的方式。
+在这种情况下，C++将拒绝这种函数调用，并将其视为错误。
+*/
+
+
+//一些看起来彼此不同的特征标是不能共存的。例如，请看下面的两个原型:
+double cube(double x);
+double cube(double& x);
+/*
+* 您可能认为可以在此处使用函数重载，因为它们的特征标看起来不同。
+然而，请从编译器的角度来考虑这个问题。假设有下面这样的代码:
+*/
+cout << cube(x);
+
+/*
+* 参数x与double x原型和double &x原型都匹配，
+因此编译器无法确定究竟应使用哪个原型。
+为避免这种混乱，编译器在检查函数特征标时，
+将把类型引用和类型本身视为同一个特征标。
+*/
+
+
+//匹配函数时，并不区分const和非const变量。请看下面的原型:
+void dribble(char* bits);				//overloaded
+void dribble(const char* bits);			//overloaded
+void dabble(char* bits);				//not overloaded
+void drivel(const char* bits);			//not overloaded
+
+//下面列出了各种函数调用对应的原型：
+const char p1[20] = "How's the weather?";
+char p2[20] = "How's business?";
+dribble(p1);				//dribble(const char* bits)
+dribble(p2);				//dribble(char* bits)
+dabble(p1);					//no match
+dabble(p2);					//dabble(char* bits)
+drivel(p1);					//drivel(const char* bits)
+drivel(p2);					//drivel(const char* bits)
+
+/*
+* dribble()函数有两个原型，一个用于const 指针，
+另一个用于常规指针，编译器将根据实参是否为const来决定使用哪个原型
+。dribble()函数只与带非const参数的调用匹配，
+而 drivel()函数可以与带const或非const参数的调用匹配。
+drivel()和 dabble( )之所以在行为上有这种差别，
+主要是由于将非const值赋给const变量是合法的，但反之则是非法的。
+*/
+
+
+//注意：请记住，是特征标，而不是函数类型使得可以对函数进行重载。
+//例如，下面的两个声明是互斥的:
+long gronk(int n, float m);			//same signatures
+double gronk(int n, float m);		//hence not allowed	
+
+//因此，C++不允许以这种方式重载gronk( )。返回类型可以不同，
+//但特征标也必须不同:
+long gronk(int n, float m);			//different signatures
+double gronk(float n, float m);		//hence allowed	
+
+
+/*
+*						重载引用参数
+* 类设计和STL经常使用引用参数，因此知道不同引用类型的重载很有用。
+请看下面三个原型:
+* 
+*/
+void sink(double& r1);			//matches modifiable lvalue
+void sink(const double& r2);	//matches modifiable or const lvalue,rvalue
+void sink(double&& r3);			//matches rvalue
+
+
+/*
+* 1.左值引用参数rl与可修改的左值参数(如double变量)匹配;
+* 
+* 
+2.const 左值引用参数r2与可修改的左值参数、
+const 左值参数和右值参数（如两个double值的和）匹配;
+
+3.最后，右值引用参数r3与右值匹配。
+注意到与rl或r3匹配的参数都与r2匹配。
+这就带来了一个问题:如果重载使用这三种参数的函数，
+结果将如何?答案是将调用最匹配的版本:
+* 
+*/
+void staff(double& rs);			//matches modifiable lvalue
+void staff(const double& rcs);	//matches rvalue,const lvaue
+void stove(double& r1);			//matches modifiable lvalue
+void stove(const double& r2);	//matches const lvalue
+void stove(double&& r3);		//matches rvalue
+
+
+//这让您能够根据参数是左值、const还是右值来定制函数的行为:
+double x = 55.5;
+const double y = 32.0;
+stove(x);					//calls stove(double& )
+stove(y);					//calls stove(const double& )
+stove(x + y);				//calls  stove(double&& )
+
+//如果没有定义函数stove(double &&)，
+//stove(x+y)将调用函数stove(const double &)。
\ No newline at end of file