1. 形参名字
#include <iostream>
using namespace std;
class A
{
public:
//形参是i
int f(int i)
{
cout << "int f(int i)" << endl;
return 0;
}
//形参是n
int f(int n)
{
cout << "int f(int n)" << endl;
return 0;
}
//形参无名字
int f(int)
{
cout << "int f(int)" << endl;
return 0;
}
//形参无名字,类型Int只是int的别名
typedef int Int;
int f(Int)
{
cout << "int f(Int)" << endl;
return 0;
}
};
int main()
{
A a;
int i = 1;
a.f(i);
return 0;
}
- 形参名字仅仅起帮助记忆的作用,它对形参列表的内容无影响。
- 实例中4个函数都是等价的,在程序中只能使用1个,否则会出现函数重复声明的错误。
int f(int i)
int f(int n)
int f(int)
int f(Int)
2. 返回类型
#include <iostream>
using namespace std;
class A
{
public:
//返回类型是int
int f(int i)
{
cout << "int f(int i)" << endl;
return 0;
}
//返回类型是const int
const int f(int i)
{
cout << "const int f(int i)" << endl;
return 0;
}
//返回类型是double
double f(int i)
{
cout << "double f(int i)" << endl;
return 0;
}
};
int main()
{
A a;
int i = 1;
const int ci = 2;
double d = 3.14;
a.f(i);
a.f(ci);
a.f(d);
return 0;
}
- 函数三要素:返回类型、函数名、形参类型。
- 不允许两个函数除返回类型外其它所有要素都相同,即不能通过返回类型区分两个函数。
- 实例中3个函数都是等价的,在程序中只能使用1个,否则会出现函数重复声明的错误。
int f(int i)
const int f(int i)
double f(int i)
3. 形参本身是const
#include <iostream>
using namespace std;
class A
{
public:
//形参类型是int
int f1(int i)
{
cout << "int f(int i)" << endl;
return 0;
}
//形参类型是const int
int f1(const int i)
{
cout << "int f(const int i)" << endl;
return 0;
}
//形参类型是int *
int f2(int *i)
{
cout << "int f(int *i)" << endl;
return 0;
}
//形参类型是int *const
int f2(int *const i)
{
cout << "int f(int *const i)" << endl;
return 0;
}
};
int main()
{
A a;
int i = 1;
const int ci = 2;
int *p1 = &i;
int *const p2 = &i;
a.f1(i);
a.f1(ci);
a.f2(p1);
a.f2(p2);
return 0;
}
- 顶层const即本身是常量,底层const即指向的对象是常量。
- 实参初始化形参时,形参的顶层const会被忽略,即无法通过判断形参是否是顶层const来区分函数。
- 实例中,两个f1是没有区别,编程时只能任选一个,两个f2也是没有区别,只能任选一个。
int f1(int i)
int f1(const int i)
int f2(int *i)
int f2(int *const i)
4. 形参是指向const
#include <iostream>
using namespace std;
class A
{
public:
//形参类型是int*
int f(int *i)
{
cout << "int f(int *i)" << endl;
return 0;
}
//形参类型是const int *
int f(const int *i)
{
cout << "int f(const int *i)" << endl;
return 0;
}
//形参类型是int &
int f(int &i)
{
cout << "int f(int &i)" << endl;
return 0;
}
//形参类型是const int &
int f(const int &i)
{
cout << "int f(const int &i)" << endl;
return 0;
}
};
int main()
{
A a;
int i = 1;
const int ci = 2;
int *p1 = &i;
const int *p2 = &i;
a.f(p1); //p1指向int,所以重载int f(int *i)
a.f(p2); //p2指向const int,所以重载int f(const int *i)
a.f(i); //i是int,所以重载int f(int &i)
a.f(ci); //ci是const int,所以重载int f(const int &i)
return 0;
}
- 若形参是指向const的指针或引用,底层const不可忽略,即可通过判断实参是否指向const选择重载函数。
- 若形参是指向const的指针或引用,函数可以接受常量或非常量的实参。若形参指向或引用的不是const,函数只能接受非常量的实参。
- 实例中4个函数都是不同的,根据实参的不同决定重载对象的函数。
int f(int *i)
int f(const int *i)
int f(int &i)
int f(const int &i)
5. 常量成员函数
#include <iostream>
using namespace std;
class A
{
public:
//普通成员函数
int f1(int i)
{
cout << "int f1(int i)" << endl;
return 0;
}
//常量成员函数
int f2(int i) const
{
cout << "int f2(int i) const" << endl;
return 0;
}
//普通成员函数
int f3(int i)
{
cout << "int f3(int i)" << endl;
return 0;
}
//常量成员函数
int f3(int i) const
{
cout << "int f3(int i) const" << endl;
return 0;
}
};
int main()
{
int i = 1;
A a;
const A ca;
//类的对象不是常量时,可以调用常量或非常量的成员函数
a.f1(i);
a.f2(i);
//类的对象是常量时,只能调用常量成员函数
// ca.f1(i); //错误
ca.f2(i);
cout << "---------------------------" << endl;
//重载函数
a.f3(i);
ca.f3(i);
return 0;
}
- 常量对象,及对它的引用和指针只能调用常量成员函数。可通过区分类的对象是否是常量决定重载函数。