C++独立编译和命名空间

---

独立编译

之前介绍过，ADT(抽象数据类型)将类的接口和实现区分开。我们应该确保所有类定义都是ADT。那么类接口与实现可以使用两个文件，可以独立编译这两个文件而不会对另一个文件产生影响。

比如下面我们将一个接口放到名为 dtime.h 的文件中。扩展名 .h 表明这是一个头文件。所有接口文件都是头文件，所以文件名肯定有扩展名 .h。

有的C++程序员和IDE选择为接口文件使用.hpp扩展名而不是.h。hpp的一个好处是一眼就能看出这是C++文件。.h最初为C所用。如某个项目兼具 C 和 C++代码，则 .hpp 有利于区分。有的程序员还将实现放到 .hpp 文件中。由模板和内联函数构成的库更加如此。

// 头文件 dtime.h：这是 DigitalTime 类的“接口”部分
// 这个类型的值表示一天当中的时间。值采取24小时制进行输入和输出
//例如，9:30 表示 9:30 AM，14.45 表示 2:45 PM
#ifndef DTIME_H
#define DTIME_H
#include <iostream>
using namespace std;

namespace dtimesavitch
{
    class DigitalTime
    {
    public:
        friend bool operator == (const DigitalTime& time1, const DigitalTime& time2);
        // 如果 time1 和 time2 代表相同的时间，就返回 true；否则返回 false

        DigitalTime(int theHour, int theMinute);
        // 前条件：0 <= theHour <= 23，而且 0 <= the Minute <= 59
        // 将时间值初始化为 theHour 和 theMinute

        DigitalTime();
        // 将时间值初始化为 0:00（午夜）

        void advance(int minutesAdded);
        // 前条件：对象已经有一个时间值
        // 后条件：时间被更改为minutesAdded分钟之后

        void advance(int hoursAdded, int minutesAdded);
        // 前条件：对象已经有一个时间值
        // 后条件：将时间值调后hoursAdded小时加minutesAdded分钟

        friend istream& operator >>(istream& ins, DigitalTime& theObject);
        // 重载>>操作符，允许输入DigitalTime类型的值
        // 前条件：如果 ins 是一个文件输入流，那么 ins 已经与一个文件连接

        friend ostream& operator <<(ostream& outs, const DigitalTime& theObject);
        // 重载<<操作符，允许输出DigitalTime类型的值
        // 前条件：如果outs是一个文件输出流，那么outs已经与一个文件连接
    private: // 这是实现的一部分，不是接口的一部分。修饰符private表明这不是公共接口的一部分
        int hour;
        int minute;
    };
} // 结束 dtimesavitch
#endif // DTIME_H

这里的 #ifdef 是为了防止一个文件多次包含 dtime.h 的定义，且C++不允许多次定义同一个类，即使重复的是完全相同的定义。

在实现文件 dtime.cpp 中，必须使用 #include "dtime.h" 预编译指令。使用尖括号 <> 表明头文件是预定义头文件，引号"" 则表明是自己编写的头文件。

// 实现文件 dtime.cpp(你的系统可能要求不用于.cpp的一个扩展名)：
// 这是ADT类DigitalTime的"实现"部分
// DigitalTime类的接口放在头文件 dtime.h 中
#include <iostream>
#include <cctype>
#include <cstdlib>
#include "dtime.h"
using namespace std;

namespace
{
    // 以下函数声明在重载的输入操作符>>的定义中使用：

    void readHour(istream& ins, int& theHour);
    // 前条件：流 ins 中的下一个输入是一个采用 24 小时制的时间，比如 9:45 或 14:45
    // 后条件：theHour 被设为时间的小时部分，冒号被舍弃，读取的下一个输入将是分钟数

    void readMinute(istream& ins, int& theMinute);
    // readHour 函数读取了小时数之后，这个函数从流 ins 中读取分钟数

    int digitToInt(char c);
    // 前条件：c是'0'~'9'的一个数字
    // 返回数字的整数值：例如，digitToInt('3')返回3
} // 无名命名空间

namespace dtimesavitch
{
    bool operator == (const DigitalTime& time1, const DigitalTime& time2)
    {
        return (time1.hour == time2.hour && time1.minute == time2.minute);
    }

    // 使用iostream和cstdlib
    DigitalTime::DigitalTime(int theHour, int theMinute)
    {
        if (theHour < 0 || theHour > 23 || theMinute < 0 || theMinute > 59)
        {
            cout << "Illegal argument to DigitalTime constructor.";
            exit(1);
        }
        else
        {
            hour = theHour;
            minute = theMinute;
        }
    }

    DigitalTime::DigitalTime() : hour(0), minute(0)
    {
        // 主体有意留空
    }

    void DigitalTime::advance(int minutesAdded)
    {
        int grossMinutes = minute + minutesAdded;
        minute =  grossMinutes;

        int hourAdjustment = grossMinutes/60;
        hour = (hour + hourAdjustment)%24;
    }

    void DigitalTime::advance(int hoursAdded, int minutesAdded)
    {
        hour = (hour + hoursAdded) % 24;
        advance(minutesAdded);
    }

    // 使用iostream:
    ostream& operator <<(ostream& outs, const DigitalTime& theObject)
    {
        outs << theObject.hour << ':';
        if (theObject.minute < 10)
            outs << '0';
        outs << theObject.minute;
        return outs;
    }

    // 使用iostream:
    istream& operator >>(istream& ins, DigitalTime& theObject)
    {
        readHour(ins, theObject.hour);
        readMinute(ins, theObject.minute);
        return ins;
    }
} // dtimesavitch

namespace
{
    int digitToInt(char c)
    {
        return (static_cast<int>(c) - static_cast<int>('0'));
    }

    // 使用 iostream, cctype和cstdlib:
    void readMinute(istream& ins, int& theMinute)
    {
        char c1, c2;
        ins >> c1 >> c2;

        if (!(isdigit(c1) && isdigit(c2)))
        {
            cout << "Error illegal input to readMinute\n";
            exit(1);
        }

        theMinute = (digitToInt(c1) * 10) + digitToInt(c2);

        if (theMinute < 0 || theMinute > 59)
        {
            cout << "Error illegal input to readMinute\n";
            exit(1);
        }
    }

    // 使用 iostream, cctype 和 cstdlib:
    void readHour(istream& ins, int& theHour)
    {
        char c1, c2;
        ins >> c1 >> c2;
        if ( !( isdigit(c1) && (isdigit(c2) || c2 == ':') ) )
        {
            cout << "Error illegal input to readHour\n";
            exit(1);
        }

        if (isdigit(c1) && c2 == ':')
        {
            theHour = digitToInt(c1);
        }
        else // (isdigit(c1) && isdigit(c2))
        {
            theHour = (digitToInt(c1) * 10) + digitToInt(c2);
            ins >> c2; //舍弃':'
            if (c2 != ':')
            {
                cout << "Error illeagl input to readHour\n";
                exit(1);
            }
        }

        if ( theHour < 0 || theHour > 23 )
        {
            cout << "Error illegal input to readHour\n";
            exit(1);
        }
    }

} // 无名命名空间

如果有程序要使用 ADT 类 DigitalTime，必须包含 include 预编译指令：#include "dtime.h"。注意，无论实现文件还是程序文件，都必须包含上述命名了接口文件的 include 预编译指令。包含程序的文件（也就是包含程序 main 部分的文件）通常称为应用程序文件或驱动程序文件。下面以 main.cpp 文件进行演示：

#include <iostream>
#include "dtime.h"

void readHour(int& theHour);

int main()
{
    using namespace std;

    using namespace dtimesavitch;

    int theHour;
    readHour(theHour);

    DigitalTime clock, oldClock;

    cout << "Enter the time in 24 hour notation: ";
    cin >> clock;

    oldClock = clock;
    clock.advance(15);
    if(clock == oldClock)
        cout << "Something is wrong.";
    cout << "You entered " << oldClock << endl;
    cout << "15 minutes later the time will be "
          << clock << endl;

    clock.advance(2, 15);
    cout << "2 hours and 15 minutes after that\n"
          << "the time will be "
          << clock << endl;
    return 0;
}
void readHour(int& theHour)
{
    using namespace std;

    cout << "Let's play a time game.\n"
         << "Let's pretend the hour has just changed.\n"
         << "You may write midnight as either 0 or 24,\n"
         << "but, I will always write it as 0.\n"
         << "Enter the hour as a number (0 to 24): ";
    cin >> theHour;
    if (theHour == 24)
        theHour = 0;
}

---

命名空间

一个程序使用有不同程序员写的不同的类和函数时，可能出现两个程序员为两样不同的东西使用同一名称的情况。命名空间就是为了解决这一问题而设计的。命名空间是名称定义(比如类定义和变量声明)的集合。上面的示例也使用了命名空间，下面对此进行详细地介绍。

命名空间和using预编译指令

前面已用过 std 的命名空间，其中含有标准库文件(比如 iostream 和 cstdlib) 定义的所有名称。例如，讲以下语句放到文件起始位置：

#include <iostream>

就会将所有名称定义(比如 cin 和 cout 等名称的定义)放到 std 命名空间。除非指定要使用 std 命名空间，否则程序不知道 std 命名空间中的人和名称。我们可以使用下面的指令使用 std 命名空间。

using namespace std;

你写的每一句代码都在某个命名空间中。不明确指定命名空间，代码就默认在 全局命名空间(global namespace) 中。全局命名空间不需要 using 指令，因为它是默认命名空间，你总是在使用这个命名空间。

注意，可同时使用多个命名空间。例如，我们总是在使用全局命名空间，同时经常要用 std 命名空间。如果一个名称在两个命名空间都进行了定义，而你同时使用了这两个命名空间，那么会发生什么？这将导致一个错误（一个编译错误或者一个运行时错误，视具体情况而定）。虽然能在两个不同的命名空间定义相同的名称，但在这种情况下，每次只能用其中一个命名空间。

但我们可以在同一个程序的不同时候使用不同的命名空间。例如，假定 ns1 和 ns2 是两个不同的命名空间，并假定 myFunction 是无参 void 函数，他在两个命名空间以不同的方式进行了定义。以下代码是合法的：

{
	using namespace ns1;
	myFunction();
}
{
	using namespace ns2;
	myFunction();
}

using 指令的作用域是它所在的那个块。如 using 指令在所有块的外部，它的作用域就从 using 指令开始，一直到整个文件结束。

创建命名空间

要将代码放到命名空间中，只需将它放到以下形式的命名空间分组中：

namespace NameSpaceName
{
	SomeCode
}

在代码中包含一个命名空间分组，相当于将 SomeCode 中定义的名称放到命名空间 NameSpaceName 中。要使用这些名称（实际是这些名称的定义），就用以下 using 指令：

using namespace NameSpaceName;

限定名称

假定两个命名空间分别是 ns1 和 ns2，你想使用 ns1 中定义的函数 fun1 以及 ns2 中定义的函数 fun2。但问题在于，在 ns1 和 ns2 这两个命名空间中，都定义了名为 myFunction 的函数。在这种情况下，以下语句是不合适的，因为它们会提供有冲突的 myFunction 定义：

using namespace ns1;
using namespace ns2;

所以，需采取一种方式，指出要使用命名空间 ns1 中的 fun1 以及命名空间 ns2 中 fun2，但不准备使用命名空间 ns1 和 ns2 中的其他任何东西。以下语句称为 using 声明，它们能解决这个问题：

using ns1::fun1;
using ns2::fun2;

using NameSpace::OneName 会使命名空间 NameSpace 中的名称 OneName 进入可用状态，但 NameSpace 中的其他任何名称仍然不可用。

using声明（比如 using std::cout;）和 using指令 (比如 using namespace std;) 有两个区别，具体如下：

• using 声明只让命名空间中的一个名称进入可用状态，而 using预编译指令 使那个命名空间中的所有名称都进入可用状态。
• using 声明 在代码中引入一个名称(比如 cout) ，不允许这个名称再有其他用途。但 using预编译指令 只是隐式引入命名空间中的名称。只要代码中不实际使用冲突的名称，就不会出问题。

比如，ns1 和 ns2 都提供了 myFunction 定义，但除此之外再无其他名称冲突，那么只要永远不在代码中使用冲突名称 myFunction ，以下语句就不会有任何问题：

using namespace ns1;
using namespace ns2;

相反，即使永远不使用 myFunction，以下语句也是非法的：

using ns1::myFunction;
using ns2::myFunction;

无名命名空间

利用无名命名空间，可以使一个定义”局部“于编译单元（也就是文件及其包含的文件）。每个编译单元都有一个无名命名空间，编译单元是一个文件。无名命名空间中定义的每个标识符对于编译单元来说都是”局部的“。要将定义放到无名命名空间，将定义放到不指定具体名称命名空间分组中即可，如下所示：

namespace
{
	Definition_1
	Definition_2
		...
	Definition_Last
}

在编译单元的范围内，可直接使用无名命名空间中的任意名称，不需要使用限定符。比如上面 DigitalTime 类定义中使用了三个辅助函数：digitToInt，readHour 和 readMinute。如果没有将其放在无命名空间中，那么就不能真正将这三个函数隐藏起来，那么这就违反了信息隐藏的原则。为真正隐藏这些辅助函数，要将它们变成 DigitalTime 实现文件的局部函数，需将这些辅助函数放到特殊的 无名命名空间(unnamed namespace) 中。