C ++ basic study notes four: overloaded function overloading

C ++ basic study notes four: overloaded function overloading

What is function overloading

In C ++, it is allowed to declare several functions of the same name with similar functions in the same scope. In other words, use the same function to complete different functions. The overloaded function is a manifestation of static polymorphism.

Features of function overloading

1. The formal parameters (referring to the number, type or order of the parameters) must be different. Function return value types can be the same or different.
2. Matching functions are not distinguished constby reference &, but will be distinguished when combined constwith *or &combined to form a composite operator. The following code will be demonstrated.
3. Avoid the pollution of the namespace

Function overloading principle

When the program is compiled, the compiler will perform the original name of the function 名称修饰, and the modified name represents the function.

Usage examples of function overloading

#include<iostream>

using namespace std;

class Printer
{
	private:
		int inkVolume;
		char printerType;
	public:
		Printer():inkVolume(0),printerType('Z')
			{cout << "print by none-arg function" <<endl;}
			
		Printer(int vol):inkVolume(vol),printerType('Z')
			{cout << "print by 1-arg function" <<endl;}
			
		Printer(int vol, char type):inkVolume(vol),printerType(type)
			{cout << "print by 2-arg function" <<endl;}
			
		//void print(int value){cout << value << " print by function #1" <<endl;}//#1
		
		void print (int value) const {cout << value << " print by const function #2" <<endl;}//#2
		
		void print(int &value){cout << value  << " print by function #3" <<endl;}//#3
		
		void print(const int &value){cout << value  << " print by function #4" <<endl;}//#4
		
		void print(int &&value){cout << value  << " print by function #5" <<endl;}//#5
		
		//int print(int value){cout << value  << " print by function #6" <<endl;return 0;}//#6仅返回值不同，编译不通过
		
		//void print(const int value){cout << value  << " print by function #7" <<endl;}//#7
		
		//void print(int value, int value2 = 1){cout << value << value2  << " print by function #8" <<endl;}//#8默认参数在后 
			
		void print(float value){cout << value  << " print by function #9" <<endl;}//#9
		
		void print(char value){cout << value  << " print by function #10" <<endl;}//#10
		
		void print(char* value){cout << *value  << " print by function #11" <<endl;}//#11
		
		void print(const char* value){cout << *value  << " print by function #12" <<endl;}//#12
		
		//void print(char* const value){cout << value  << " print by function #13" <<endl;}//#13
};

int main()
{
	Printer printer1;
	Printer printer2(123);
	const Printer printer3(123,'A');
	
	int intValue = 123;
	const int c_intValue = 1234;
	float floatValue = 1.1;
	char charValue = 'A';
	char* p_charValue = new char('B');
	const char* cp_charValue = new char('C');
	
	
	//printer1.print(1);//1 是 立即数常量 可以调用#1，#4，#5 ，#2（当且仅当仅存在#2时） 
	printer3.print(1);//只调用 #2
	printer1.print(intValue);//#3 
	printer1.print(c_intValue);//#4 
	printer1.print(1+1);//#5 
	printer1.print(floatValue);//#9
	printer1.print(charValue);//#10 
	printer1.print(p_charValue);//#11
	printer1.print(cp_charValue);//#12
	
    return 0;
}
/* 运行结果为： 
print by none-arg function
print by 1-arg function
print by 2-arg function
1 print by const function #2
123 print by function #3
1234 print by function #4
2 print by function #5
1.1 print by function #9
A print by function #10
B print by function #11
C print by function #12

--------------------------------
Process exited after 0.09048 seconds with return value 0
请按任意键继续. . .
*/

Code analysis

1. int valueAnd const int valuethere is no difference, as the parameter will not change the argument. Not overloaded.
2. char *valueAnd const char *valuethere is a difference, the former point to a string variable, which points to a string constant. Can be overloaded.
3. char *valueAnd char const *valuethere is no difference, the former is a character pointer variable, which is a character pointer constant. As a parameter, the actual parameter value will not be changed. Not overloaded.
4. int &valueAnd const int &valuethere is a difference, the former pointing to an integer variable, which points to an integer constant. Can be overloaded.
5. int &&value&& means rvalue reference