一个C++日期类（第一部分）
Chuck Allison是盐湖城圣Latter Day教堂总部下耶稣教堂家族历史研究处的软件体系设计师。他拥有数学学士和数学硕士学位。他从1975年起开始编程，从1984年起他开始从事c语言的教学和开发。他目前的兴趣是面向对象的技术及其教育。他是X3J16，ANSI C ++标准化委员会的一员。发送e-mail到[email protected]，或者拨打电话到(801)240-4510均可以与他取得联系。
上个月的专栏里介绍了一个日期间隔函数，它可以算出任意两个日期之间的年，月和日。这个月的专栏则提出了一个用C++解决该问题的方法。这种方法的本质是创建一种新的数据类型，这种数据类型的行为就像内建的数据类型一样。换句话说，你要从基于函数的方法（“我想要怎么样做事”）转换到基于对象的方法（“我的问题的原理和对象是什么”）。使用C++非常需要另外一种思考问题的方法。为了实现这个转换，首先要先知道为什么会有C++存在。
关于两种语言的故事
C++源自80年代早期AT&T的Bjarne Stroustrup提出的“带类的C”。他那时正在寻求在Simula-67中更快的进行仿真的方法。“class”是Simula中用来指用户自己定义的类型的术语，能够定义出非常接近现实的对象，这是进行良好的仿真的关键。有没有一种更好的方法，能够比在c语言——最快的过程化语言中加入“class”的概念更快的进行仿真呢？
选择C为类提供了一个不仅有效而且灵活的工具。虽然一些其他的语言在C++之前很久就支持通过类来对数据进行抽象，但是C++用的最广泛。几乎每一种主要的具有C语言编译器的平台同样能够支持C++。最后我还听说，C++的用户群每七个月就会翻一番。
对C++的最初了解是令人吃惊的。如果你是从C语言转过来的话，你需要把下面这些词语加进你的词汇表：抽象类，存取控制，基类，catch子句，类，类的作用域，构造函数，拷贝构造函数，缺省参数，缺省构造函数，delete运算符，派生类，析构函数，异常，异常处理，友元，继承，内联函数，操作符，成员函数，多重继承，嵌套类，new处理函数，new操作符，重载，成员指针，多态，私有，保护，公有，纯虚函数，引用，静态成员，流，模板，this指针，try块，类型安全连接，虚基类，虚函数。
一个好消息说C++是一种强大的、有效的、面向对象的、能够处理各种复杂应用的语言。坏消息则是这种语言本身就比较复杂，比C语言难掌握。C语言是造成这一问题的一部分。C++是一个混血儿，既有面向对象的特征，又有通用系统编程语言的特征。我们不可能纯粹介绍C++这一系列丰富的新特征而不一点也不考虑C语言本身。对C的兼容性是C++设计时的一个主要目标。正如Bjarne在ANSI C++委员会上所陈述的那样，C++是一种“工程上的折衷”，它“要和C语言尽可能的接近，但又不能太接近”。到底要多接近现在还在研究中。
一个渐进的过程
你可以很有效的使用C++而不需要掌握它的全部。事实上，面向对象的技术承诺说只要开发商做好他们的事情（提供设计良好的、可重用并且可扩展的类库），那么你就可以很容易的开发你的应用程序。目前的产品，比如Borland公司的应用编程接口，在许多方面都证明了这一点。
如果你觉得你必须掌握这门语言，你可以循序渐进并且在这个过程中继续开发你的应用程序。这里有三个必须掌握的地方：
1 一个更好的C语言
2 数据抽象
3 面向对象的编程
你可以把C++当成一门更好的C语言来使用，因为它更安全更富于表现力。与这一点相关的特征有：类型安全连接，强制函数原型，内联函数，const限定词（是的，ANSI C从C++中借鉴的这个词），函数重载，缺省参数，引用和语言提供的对动态内存管理的支持。你同样需要当心这两种语言不兼容的地方。C语言中有一个强大的子集，Plum和Saks称其做“类型安全的C”（参见C++ Programming Guidelines, Plum and Saks, Plum-Hall, 1992）。
正如我在这篇文章和下一篇文章中所陈述的一样，C++支持数据抽象——用户可以自己定义行为与内建类型相像的数据类型，这种数据抽象机制包括：类，存取限制，构造和析构函数，运算符重载，模板和异常处理。
面向对象的程序设计通过探求类与类之间的关系在数据抽象上更进一步。其中两个关键的概念是继承（通过声明一个新类与另一个类的相似与区别定义它，其中的相似被重用）和多态（为一族相关的操作提供同一个接口，运行时识别）。C++分别通过类的派生和虚汗数来支持继承和多态。
类
一个类就是一个扩展的struct。除了定义数据成员，你还可以为其添加成员函数。日期类的定义在文件data.h中的Listing 1。它与上个月的C版本不同，因为在这里interval函数是一个成员函数而不是全局函数。Date::interval()的实现在Listing 2中。“::”叫做作用域运算符。它告诉编译器interval函数是Date类的成员函数。interval函数原型中的“&”说明这个函数的参数由应用传递（参见关于引用的选项）。Listing 3中的程序展示了如何使用这个日期类。你必须使用结构成员的语法来调用Date:: interval()：
result = d1.interval (d2);
Date作为类型标识符，就像系统内建类型一样的发挥作用（例如，你可以定义Date的对象而不使用struct关键字）。永远也不必做如下的定义：
typedef struct Date Date;
事实上，类的概念是如此的基本，以至于C++已经将结构标签和普通的标识符结合成一个独立的名字空间。
注意我已经将isleap定义成了一个内联函数（在C版本中它是一个宏）。内联函数像宏一样将代码展开，但它也像普通函数一样进行作用阈和类型的检查。除非你要使用the stringizing or token-pasting operations of the preprocessor,，否则在C++中不需要使用function-like的宏。
现在考虑Listing 2中的这个声明：
years = d2.year - year;
year指的是什么对象？在C版本中，这个声明如下：
years = d2.year - d1.year;
既然成员函数的调用总是与对象相关联（例如，d1. interval (d2)），因此当成员函数没有前缀修饰的时候，通常是相关联对象的成员（在这里，year 指的是d1.year）。this关键字代表一个指向潜在对象的指针，因此我可以做一个更加明确的声明：
years = d2.year - this->year;
但是这种用法很少。
In Listing 4中，我在类的定义中添加了如下的声明：
Date();
Date(int,int,int);
这是一种特殊的成员函数叫做构造函数。构造函数允许你在一个对象被创建的时候指定怎么样初始化这个对象。当你定义一个没有初始值的日期对象时，首先调用缺省构造函数（因为它没有任何参数）：
Date d;
下面的声明调用第二个构造函数：
Date d(10,1,51);
当成员函数的实现比较简单的时候，你可以把它们的实现移到类的定义里面去，使它们成为内联函数（参见Listing 7－不要忘记在Listing 5中移走它们）。Listing 6中的测试程序推迟构造对象d1、 d2和result直到需要它们的时候（在C++中，对象的定义可以出现在任何声明中）。
我几乎已经列举了数据抽象，也就是封装的主要特征。当一个用户自定义类型的内部表现和外部接口设计良好，就叫做一个封装。我确实定义了一个和系统内建类型一样作用的新类型，我不允许任何无意间的对它的内部表现的访问制。例如，像这样，用户可以执行如下的语句：
d1.month = 20;
一个行为良好的对象控制着对它的内部数据成员的访问。在一个实际的日期类中，我允许用户对年月日进行排队，但不允许直接设置它们的值。因此我定义它们为private，并且提供了存取函数来得到它们的值（参见 Listing 8）。既然具有私有成员是更普遍的情况，我通常用class关键字取代struct，class的成员默认为private。类似get_month这样的读取函数不改变一个日期类的私有部分，因此我声明它们为const成员函数。（Date::interval()也是一个const——别忘了在实现文件date3.cpp中它的定义前加const。）
我们现在在完成一个C++风格的函数上只走了一半的路。下个月我们会把输入输出流、静态成员和运算符重载结合进来讨论。
C++中的引用
C++中的引用是另一个对象的别名。它所引用的对象出现的地方，它本身就可以出现。下面的程序使用引用iref代替i：
/* ref1.c: Illustrate references */
#include <stdio.h>
main()
{
int i = 10;
int &iref = i; // An alias for i
printf("%d/n",iref);
iref = 20;
printf("%d/n",i);
return 0;
}
/* Output:
10
20
*/
你可以把引用看作一个“灵巧”指针，因为它指向另一个对象却又不像指针一样需要明确的寻址和取值：
/* ptr.c: Do the same thing with pointers */
#include <stdio.h>
main()
{
int i = 10;
int *iref = &i;
printf("%d/n" ,*iref);
*iref = 20;
printf("%d/n",i);
return 0;
}
指针和引用的主要区别在于：
· 你必须用引用所指对象来初始化这个引用。这样的声明是没有意义的（除非作为函数的参数）：
int &iref;
一旦初始化了一个引用，你不能使这个引用指向另外的对象。既然引用总是需要指向某些东西，你不能像对指针一样给它赋值为NULL。
· 引用既不需要也不允许&和*操作符的使用，所有的寻址和取值都是自动的。你可以把引用看作一个const指针，每次使用的时候都会取值。
然而，就像指针一样，引用也可以作为函数的返回值。既然引用被定义成一个左值，这就允许一个很特殊的习惯，那就是在完成某任务时，可以将对函数的调用放在=的左手边：
/* ref2.cpp: Returning a reference */
#include <stdio.h>
int & current(); // Returns a reference
int a[4] = {0,1,2,3};
int index = 0;
main()
{
current() = 10;
index = 3;
current() = 20;
for (int i = 0; i < 4; ++i)
printf("%d ",a[i]);
putchar('/n');
return 0;
}
int & current()
{
return a[index];
}
/* Output:
10 1 2 20
*/
另一种引用的用法是实现引用传递语义，这意味着在被调用函数返回后改变调用进程中存在的函数参数值。你也可以用指针实现，但是引用更明确：
/* ref3.cpp:
Swap via references */
#include <stdio.h>
void swap(int &, int &);
main()
{
int i = 1, j = 2;
swap(i,j);
printf("i == %d, j == %d/n",i,j);
return 0;
}
void swap(int &x, int &y)
{
int temp = x;
x = y;
y = temp;
}
/* Output:
i==2, j == 1
*/
即使你不打算修改函数的参数，为了提高效率用引用来传递大的对象也是一个好办法。例如，假如数据类型X很大，
struct X
{
// lotsa stuff
};
那么具有X类型参数、却不会修改该参数的函数f应该有类似下面的原型：
void f(const X&);
想要了解引用的更多内容，参见Dan Saks'在1991年第九期的专栏"Reference Types", CUJ Vol. 9, No. 9。
Listing 1 Date类的成员定义
// date.h: A simple date class
struct Date
{
int month;
int day;
int year;
Date * interval(const Date&);
};
/* End of File */
Listing 2 Date::interval()的实现
//date.cpp: Implement the Date class
#include "date.h"
inline int isleap(int y)
{return y%4 == 0 && y%100 != 0 || y%400 == 0;}
static int Dtab[2][13] =
{
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
Date * Date::interval(const Date& d2)
{
static Date result;
int months, days, years, prev_month;
// Compute the interval - assume d1 precedes d2
years = d2.year - year;
months = d2.month - month;
days = d2.day - day;
// Do obvious corrections (days before months!)
//
// This is a loop in case the previous month is
// February, and days < -28.
prev_month = d2.month - 1;
while (days < 0)
{
// Borrow from the previous month
if (prev_month == 0)
prev_month = 12;
--months;
days += Dtab[isleap(d2.year)][prev_month--];
}
if {months < 0)
{
// Borrow from the previous year
--years;
months += 12;
}
/* Prepare output */
result.month = months;
result.day = days;
result.year = years;
return &result;
}
/* End of File */
Listing 3 使用Date类的示例
// tdate.cpp: Test the Date class
#include <stdio.h>
#include <stdlib.h>
#include "date.h"
main()
{
Date d1, d2, *result;
int nargs;
// Read in two dates - assume 1st precedes 2nd
fputs("Enter a date, MM/DD/YY> ",stderr);
nargs = scanf("%d/%d/%d%*c", &d1.month,
&d1.day, &d1.year);
if (nargs != 3)
return EXIT_FAILURE;
fputs("Enter a later date, MM/DD/YY> ",stderr);
nargs = scanf("%d/%d/%d%*c", &d2.month,
&d2.day, &d2.year);
if (nargs != 3)
return EXIT_FAILURE;
// Compute interval in years, months, and days
result = d1.interval(d2);
printf("years: %d, months: %d, days: %d/n",
result->year, result->month, result->day);
return EXIT_SUCCESS;
}
/* Sample Execution:
Enter a date, MM/DD/YY> 10/1/51
Enter a later date, MM/DD/YY> 11/14/92
years: 41, months: 1, days: 13
*/
/* End of File */
Listing 4 Listing 5所示的变化后的Date类的定义
// date2.h
struct Date
{
int month;
int day;
int year;
// Constructors
Date();
Date(int, int, int);
Date * interval (const Date&);
};
/* End of File */
Listing 5 变化后的Date类
// date2.cpp
#include "date2.h"
inline int isleap(int y)
{return y%4 == O && y%100 != 0 || y%400 == 0;}
static int Dtab [2][13] =
{
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
Date * Date::interval (const Date& d2)
{
(same as in Listing 2)
}
Date::Date()
{
month = day = year = 0;
}
Date::Date(int m, int d, int y)
{
month = m;
day = d;
year = y;
}
/* End of File */
Listing 6 ： Date类的测试程序
// tdate2.cpp
#include <stdio.h>
#include <stdlib.h>
#include "date2.h"
main()
{
int m, d, y, nargs;
// Read in two dates - assume 1st precedes 2nd
fputs("Enter a date, MM/DD/YY> ",stderr);
nargs = scanf("%d/%d/%d%*c", &m,&d,&y);
if (nargs != 3)
return EXIT_FAILURE;
Date d1(m,d,y);
fputs("Enter a later date, MM/DD/YY> ",stderr);
nargs = scanf("%d/%d/%d%*c", &m,&d,&y);
if (nargs != 3)
return EXIT_FAILURE;
Date d2(m,d,y);
// Compute interval in years, months, and days
Date *result = d1.interval(d2);
printf("years: %d, months: %d, days: %d/n",
result->year, result->month, result->day);
return EXIT_SUCCESS;
}
/* End of File */
Listing 7 将成员函数的实现放到类定义中去
// date2.h
struct Date
{
int month;
int day;
int year;
// Constructors
Date()
{month = day = year = 0;}
Date(int m, int d, int y)
{month = m; day = d; year = y;}
Date * interval(const Date&);
};
/* End of File */
Listing 8 使用存取函数获取变量值的类定义
// date3.h
struct Date
{
private:
int month;
int day;
int year;
public:
// Constructors
Date()
{month = day = year = 0;}
Date(int m, int d, int y)
{month = m; day = d; year = y;}
// Accessor Functions
int get_month() const
{return month;}
int get_day() const
{return day;}
int get_year() const
{return year;}
Date * interval(const Date&) const;
};
/* End of File */
Listing 9 用class代替struct的类定义
// date3.h
class Date
{
int month;
int day;
int year;
public:
// Constructors
Date()
{month = day = year = 0;}
Date(int m, int d, int y)
{month = m; day = d; year = y;}
// Accessor Functions
int get_month() const
{return month;}
int get_day() const
{return day;}
int get_year() const
{return year;}
Date * interval(const Date&) const;
};
/* End of File */