条款24：在函数重载（function overloading）和参数缺省化（parameter defaulting）之间，谨慎抉择

1，引起混淆基于一个事实:他们都允许以不同的形式调用同一个函数名称。
如：
void f();                             // f is overloaded

void f(int x);

f();                                  // calls f()

f(10);                                // calls f(int)



void g(int x = 0);                    // g has a default

                                      // parameter value

g();                                  // calls g(0)

g(10);                                // calls g(10)

2，应该使用哪个，答案取决于两个方面：
（1）是否有适当的值可以用来作为缺省参数。
（2）希望使用多少个算法.
如果可以选择合理的默认值，而且你需要一个算法，那么最好使用缺省函数。

3，举例
（1）缺省函数的版本：返回最多5个数的最大值
只需要一个即可：
int max(int a,

        int b = std::numeric_limits<int>::min(),

        int c = std::numeric_limits<int>::min(),

        int d = std::numeric_limits<int>::min(),

        int e = std::numeric_limits<int>::min())

{

int temp = a > b ? a : b;

temp = temp > c ? temp : c;

temp = temp > d ? temp : d;

return temp > e ? temp : e;

}
（2）如果没有合适的默认值，只能使用函数重载：返回最多5个整数的平均值。
double avg(int a);

double avg(int a, int b);

double avg(int a, int b, int c);

double avg(int a, int b, int c, int d);

double avg(int a, int b, int c, int d, int e)

4，另外一种必须使用函数重载的情况：采用的算法视输入而定.
如：构造函数和拷贝函数
class Natural
{

public:

Natural(int initValue);

Natural(const Natural& rhs);

private:

unsigned int value;

void init(int initValue);

void error(const string& msg);

};

inline

void Natural::init(int initValue) { value = initValue; }

Natural::Natural(int initValue)

{

if (initValue > 0) init(initValue);

else error("Illegal initial value");

}

inline Natural::Natural(const Natural& x)

{ init(x.value); }
//私有成员函数init，避免两个constructors内部部分代码重复。