用别名指定名字空间

    名字空间可以一层层嵌套，指定时也得一层层地指定，这样很不方便，一般用 别名代替就方便多了。

    #include  using namespace std; namespace na { namespace nb { namespace nc { int sum(int

    {

    a,

    int

    b)

    return

    } } } }

    a + b;

    namespace int

    {

    A = na::nb::nc;

    main ( )

    cout << na::nb::nc::sum(5, 11) << endl; cout << A::sum(6, 12) << endl;

    return

    }

    0;

    四、没有名字的名字空间

    名字空间的名字也可以省略，称之为“无名名字空间”，无名名字空间经常被使 用，其作用是“内部可以引用，而外部不能引用”。

    #include using namespace

    std;

    namespace na { namespace { //无名名字空间 int sum(int a, int b)

    {

    return

    } }

    a + b;

    int

    {

    calc(int x,

    int

    y)

    return

    } }

    sum(x, y);

    //内部可以调用无名名字空间的变量或函数

    int

    {

    main ( )

    //cout << na::sum(5, 11) << endl; 以外部不能调用

    cout << na::calc(6, 12) << endl;

    //因为缺少里面的名字，所

    return

    }

    0;

    03 章 缺省参数和函数重载

    一、参数的缺省值

    在 C++中参数可以设置缺省值，设置了缺省值之后，这个参数在调用时可以省 略。注意：设置缺省值的参数只能是最后的几个参数。也就是说某一个参数一旦设 置了缺省值，其后而的参数也必须设置缺省值。例如：f()函数有 3 个参数，如果只 设置第 2 个有缺省值，这就错了。因为调用时只输入 2 个参数时，系统不知道究竟 是第 2 个参数还是第 3 个参数。

    #include  using namespace std;

    int sum(int x=0, int y=100, int z=0) { return x+y+z; } //int sum(int x, int y=100, int z=0) { …… } //这是正确的 //int sum(int x, int y, int z=0) { …… } //这也是正确的 //int plus(int x, int y=100, int z) { …… } //这是错误的 int

    { cout << sum() << endl; cout << sum(6) << endl; cout << sum(6, 10) << endl; cout << sum(6, 10, 20) << endl; main ( )

    return

    }

    0;

    二、函数的重载

    函数的重载在 C++中具有重要作用，重载(overload)不要和后面要学的覆盖 (override)混淆起来。重载是指相同的函数名，但参数的类型或个数中只要有所不同， 便进行再定义，编译之后重载的函数都具有不同的地址，也就是说虽然函数名相同， 实际上是不同的函数，在调用时，编译系统会根据不同之处自动区别是调用哪一个 函数。对于普通函数和后面要学的类的成员函数都适用。 覆盖只对类的构造函数或成员函数适用，是子类继承父类是才使用的非常有用 的功能。重载可以针对运算符，而覆盖不行。上一节中缺省值的设置，实际上在编 译时等价于重载，被生成了 4 个不同的函数。 早期的 C++版本，在定义重载函数时要加上关键字 overload，现在不用了。在 使用重载函数时，如果有类型的自动转换时要特别注意，初学者往往出错在这儿。

    #include  using namespace std; float fun(float x); double fun(double x); int

    { float f = 132.64; main ( )

    double

    d = 132.64;

    cout << fun(f) << endl; cout << fun(d) << endl;

    //cout << fun(5) << endl; 也可转换为 double return

    } 0;

    //编译错， 参数 5 可以转换为 float，

    float

    {

    fun(float x)

    return

    }

    x / 2.0 ;

    double

    {

    fun(double x)

    return

    }

    x / 3.0;

    三、设计时的重载错误

    上面的例子中，设计时并没有问题，调用时类型自动转换时发生了二义性。下 面列举的重载函数是设计时就出了问题，二个函数本身就具有重复的意义。

    #include  using namespace std; int int int

    { fun(int a, fun(int a,

    int int

    b); &b);

    main ( )

    int

    x=1, y=2;

    cout << fun(x, y) << endl;

    //这句编译时出错

    return

    }

    0;

    int

    {

    fun(int a,

    int

    b);

    return

    a + b;

    }

    int

    {

    fun(int a,

    int&

    b);

    return

    }

    a - b;

    上面例子用到了 int&，这叫“引用”，关于什么是“引用”参见下一章。

    四、重载函数的地址

    本节利用函数指针的方法来取函数的地址，有关函数指针请参考“C 语言教程” 的章节。本节虽没有特别高深内容，但初学者还是跳过为好。

    #include  using namespace std; void void int

    { space(int count); space(int count,

    char

    ch);

    main ( )

    //有一个整型参数的函数指针 void (*fp1)(int); //有一个整型参数、一个字符型参数的函数指针 void (*fp2)(int, char);

    fp1 = space; fp2 = space;

    //取 space(int)函数的地址 //取 space(int, char)函数的地址 //输出 20 个空格 //输出 20 个等号

    fp1(20);

    cout << "|" << endl; fp2(20, '=');

    cout << "|" << endl;

    return

    }

    0;

    //输出 count 个空格字符

    void

    {

    space(int count)

    for

    }

    ( ; count; count--) cout << ' ';

    //输出 count 个 ch 字符 void space(int count, char

    {

    ch)

    for

    ( ; count; count--) cout << ch;

    04 章 引用

    一、独立引用

    “引用(reference)”与指针象似但不是指针。 引用主要有 3 种用法： ①单独使用(一 般称为“独立引用”)，②作参数使用，③作返回值使用。从功能上来说，引用型变量 又可以看着被引用变量的“别名”， 2 个变量只是名称不同， 这 变量的地址是同一个(共 用体中的元素也是一样)。使用“引用”的好处主要是可以“逆向引用”。 常量也可以被引用，例如：“const int &ref = 10;”，这也是正确的，但这样定义 无任何意义。定义独立引用时需要注意以下规则： 1. 引用型变量在定义时必须初始化。 2. 被引用的对象必须已经分配了空间，即不能为空，或空指针。 3. 被引用的对象不能为地址，即指针变量、数组变量等不能被引用。

    #include  using namespace std; int

    { main( )

    int int

    a ; &b = a;

    //b 和 a 实际上是同一变量 //b 赋值为 100，也就是 a 赋值为 100

    b = 100;

    cout << a << endl;

    //a 的地址和 b 的地址应该是完全一样

    cout << &a << endl; cout << &b << endl;

    //▼下面代码有错，注释后才能运行▼int x[] = {12,15,20} ; int &y = x; //错误：数组、指针不能被引用 int int

    x1; &y1;

    //错误：引用时必须初始化

    y1 = x1;

    //▲上面代码有错，注释后才能运行▲return

    } 0;

    二、函数的参数引用 函数的参数引用

    许多教程在讲解参数引用时都喜欢选择交换两参数内容的 swap(int &x, int &y) 函数作例子，这的确很容易说明清楚，但并不能说这种用法优于指针作参数。

    #include  using namespace std; //|右边为指针作参数的代 码，仅作比较用。 void swap(int &x, int &y); int

    { main ( )

    int int

    i = 12; j = 25; j=" << j << endl;

    cout << "i=" << i << "

    swap(i, j); cout << "i=" << i << " j=" << j << endl;

    return

    }

    0;

    void swap(int &x, int &y)

    {

    int

    t;

    //|void swap(int *x, int *y); //| //| //| //| //| //| //| //|swap(&i, &j); //| //| //| //| //| //|void swap(int *x, int *y) //|{ //| int t; //|

    t = x; x = y; y = t; }

    //| //| //| //|}

    t = *x; *x = *y; *y = *x;

    三、对象引用作参数

    初学者可以先跳过这一节，待学完“类”之后再来看。

    #include  using namespace std; class

    myclass {

    int who;

    public:

    myclass(int n) { who = n; cout << "构造函数调用" << who << endl; } ~myclass() { cout << "析构函数调用" << who << endl; }

    int

    } };

    id() {

    return

    who;

    void

    }

    f1(myclass o) {

    //普通变量方式传递参数

    cout << "外部函数调用" << o.id() << endl;

    void

    }

    f2(myclass *o) {

    //指针方式传递参数

    cout << "外部函数调用" << o->id() << endl;

    void

    }

    f3(myclass &o) {

    //引用方式传递参数

    cout << "外部函数调用" << o.id() << endl;

    int

    {

    main ( )

    myclass x1(1); f1(x1); cout << "" << endl;

    myclass x2(2); f2(&x2); cout << "" << endl;

    myclass x3(3); f3(x3); cout << "" << endl;

    return

    }

    0;

    从上面例子可以看出，用普通变量方式传递参数时，函数首先将参数复制一个 副本，在函数体内使用的是副本。这个副本和参数自身不是同一个地址。而指针方 式和引用方式并不产生副本，函数体内用的真是参数自身。需要注意的是，产生副 本时调用了类的缺省“拷贝构造函数”，这个“拷贝构造函数”并不调用构造函数就产 生了一个副本，有关详细内容参见后面章节。

    四、作为函数返回值的引用类型

    这一节仍然较深，建议初学者跳过。讲解这一节内容之前，先看下面的程序， 这个程序有没有毛病？

    #include  using namespace std; int int int

    { f() = 100; cout << x << endl; &f(); x;

    main ( )

    return

    }

    0;

    int

    {

    &f()

    return

    }

    x;

    许多人都认为第 9 句错了，少数人认为第 4 句可能有问题。事实上，这个程序 完全正确。上面这个函数的返回值是引用类型，通过函数结果的设置反过来去改变 “源头”数据，这种“逆向引用”为 C++增强了很多功能，当然也有许多需要注意的地 方。由于本教程面向初学者，因此到此为止，不再深入下去。