C++ | 函数重载

函数重载

• C语言：不支持 （报错：error 函数已有主体）
  原因：函数符号的生成只依赖函数名。函数符号相同编译无法通过
• C++：支持
  原因：函数符号的生成依赖 函数名+参数列表 。重载后的各函数符号不同。

函数重载特点：

函数名相同，参数列表不同，处于同一作用域。返回值不参与重载，重载函数调用类型要明确。

实例一：函数重载

规则1：函数名相同，参数列表不同

bool Compare(int a, int b)
{
	cout << "Compare_Int_Int"<< endl;
	return a == b;
}
bool Compare(float a, float b)
{
	cout << "Compare_Float_Float" << endl;
	return a == b;
}
bool Compare(char a, char b)
{
	cout << "Compare_Char_Char" << endl;
	return a == b;
}
bool Compare(const char* a, const char* b)
{
	cout << "Compare_ConstChar*_ConstChar*" << endl;
	return !strcmp(a, b);
}


int main()
{
	Compare(5, 10);				   //输出：Compare_Int_Int
	Compare('a', 'A');			   //输出：Compare_Char_Char
	Compare("asd", "asd");		   //输出：Compare_ConstChar* _ConstChar*

	return 0;
}

实例二：作用域限定

规则2：处于同一作用域

在main() 函数中声明bool Compare(int, int); 使得在main() 函数作用域下都使用 Compare_Int_Int 。

int main()
{
	bool Compare(int, int);	// 声明使用 (int,int)类型的Compare函数

	Compare('a', 'b');			  //输出：Compare_Int_Int
	Compare(10.0f, 10.2f);		  //输出：Compare_Int_Int
	Compare(10.0, 10.2);		  //输出：Compare_Int_Int

	return 0;
}

我们重载的函数是在整个文件中的全局作用域函数，在mian() 函数内部声明的是局部作用域的函数。根据“就近原则”（如果作用域重叠，先使用小作用域。如全局变量和局部变量同名，使用局部变量）。如果我们要想使用全局函数使用::fun()的方法调用。如下：

int main()
{
	bool Compare(int, int);	// 声明使用 (int,int)类型的Compare函数

	::Compare('a', 'b');			  //输出：Compare_Char_Char
	::Compare(10.0f, 10.2f);		  //输出：Compare_Float_Float

	return 0;
}

实例三：使用关键字 const 和 volatile

规则3：与const有关的几种特殊重载

1. 参数 int 与 const int 是同一种类型

void fun(int a) { }
void fun(const int b) {}	// error : void fun(int)已有主体

int main()
{
	int a = 10;
	const int b = 20;
	fun(a);
	fun(b);

	return 0;
}	

使用<typeinfo> 中的tyeid() 查看类型信息

#include <typeinfo>

int main()
{
	int a = 10;
	const int b = 20;
	cout << typeid(a).name() << endl;		// 输出：int
	cout << typeid(b).name() << endl;		// 输出：int

	return 0;
}

2. 当使用指针或引用时，可以进行函数重载

如，以下编译器视为4个不同版本的函数重载

void fun( int * a);
void fun( const int * a);
void fun( int & a);
void fun( const int & a);

测试：

void func(int* a) { cout << "Int*" << endl; }
void func(const int* a) { cout << "ConstInt*" << endl; }
void func(int& a) { cout << "Int&" << endl; }
void func(const int& a) { cout << "ConstInt&" << endl; }


int main()
{
	int a = 10;
	const int b = 20;
	func(a);			 // 输出：Int&
	func(b);			 // 输出：ConstInt&
	func(&a);			 // 输出：Int*
	func(&b);			 // 输出：ConstInt*

	return 0;
}

3. 类成员重载

类中存在后置const的常函数，与普通类成员函数之间可以实现重载。

注：后置const作用在与this指针上，使其原本的 type * const this 指针转变为 const type * const this指针，因此在声明为后置const的常对象中不可修改类成员变量（mutable与const_cast除外）。

class A
{
public:
	void print() const;
	void print();
};


int main()
{
	A a;			// 普通对象
	A const ca;		// 常对象

	a.print();		// Print()
	ca.print();		// Printf() Const
	return 0;
}

void A::print() const
{
	cout << "Printf() Const" << endl;
}
void A::print()
{
	cout << "Print()" << endl;
}
/* 
	这里如果输出其函数修饰符与this指针，就会发现二者函数头修饰并不相同，因此它们可以使重载关系而不产生冲突。
	cout << __FUNCDNAME__ << " " << typeid(this).name() << endl;

*/