---

独立编译

之前介绍过，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 
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

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

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

// 实现文件 dtime.cpp(你的系统可能要求不用于.cpp的一个扩展名)：
// 这是ADT类DigitalTime的"实现"部分
// DigitalTime类的接口放在头文件 dtime.h 中
#include 
#include 
#include 
#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);
        }
    }

} // 无名命名空间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

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

#include 
#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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

---

命名空间

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

命名空间和using预编译指令

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

#include 
1

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

using namespace std;
1

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

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

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

{
	using namespace ns1;
	myFunction();
}
{
	using namespace ns2;
	myFunction();
}
1
2
3
4
5
6
7
8

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

创建命名空间

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

namespace NameSpaceName
{
	SomeCode
}
1
2
3
4

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

using namespace NameSpaceName;
1

限定名称

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

using namespace ns1;
using namespace ns2;
1
2

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

using ns1::fun1;
using ns2::fun2;
1
2

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;
1
2

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

using ns1::myFunction;
using ns2::myFunction;
1
2

无名命名空间

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

namespace
{
	Definition_1
	Definition_2
		...
	Definition_Last
}
1
2
3
4
5
6
7

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