《c++程序设计原理与实践》第9章——类相关的技术细节

用户自定义类型

对于一个类型,如果编译器无须借助程序员在源码中提供的任何声明,就知道如何表示这种类型的对象以及可以对它进行什么样的运算,那么我们就称这种类型是内置的 。
非内置的类型称为用户自定义类型 。 用户自定义类型包括每个ISO标准C++实现都提供给程序员的标准库类型,如string、vector和ostream,也可以是我们为自己创建的类型。标准库类型很大程度上可以和内置类型一样看作语言的一部分,但我们还是将它们看作用户自定义类型。通过类型,我们可以用代码直接、有效地表达我们的思想。这些类型带来的帮助体现在两个方面:
表示:一个类型“知道”如何表示对象中的数据
运算:一个类型“知道”可以对对象进行什么运算
我们希望在代码中将这样一个“想法”或“概念”表示为一个数据结构加上一组函数。C++提供了两类用户自定义数据类型:类和枚举。类能够在程序中直接地表达概念。一个类 是一个用户自定义类型,它指出这种类型地对象如何表示,如何创建,如何使用,以及如何销毁。

类和成员

一个类就是一个用户自定义类型,由一些内置类型、其他用户自定义类型以及一些函数组成。这些用来定义类的组成部分称为成员 。一个类可以有零个或多个成员。例如:

class X{
public:
    int m;                                          //数据成员
    int mf(int v)  {int old=m;m=v;return old;}      //函数成员
};

成员可以有多种类型,大多数要么是数据成员(定义了类对象的表示方式),要么是函数成员(提供类对象之上的运算)。类成员的访问使用符号object.member 。成员函数可以直接使用成员名字。

接口和实现

我们通常把类看作接口加上实现。接口是类声明的一部分,用户可以直接访问它。实现是类声明的另一部分,用户只能通过接口间接访问它。公有的接口用标号public:标识,实现用标号private:标识。可以将一个类声明理解为如下形式:

class X{    //类的名字为X
public:
    //公有成员:
    //~用户接口(可被所有人访问)
    //函数
    //类型
    //数据(通常最好为private)
private:
    //私有成员:
    //~实现细节(仅能被该类的成员访问)
    //函数
    //类型
    //数据
};

类成员默认是私有的,用户不能直接访问一个私有成员,应通过一个公有函数来访问。如果类只包含数据的话,接口和实现间的区别没有什么意义。C++提供了结构(struct)用来描述没有私有实现细节的类,一个结构就是一个成员默认为公有属性的类。

演化一个类

成员函数和构造函数

将函数声明于类体内,作为类的成员的技术称为成员函数。成员函数能保证程序员不会忘记初始化函数以及不会忽视可能性很低的操作。与类同名的成员函数是特殊的成员函数,称为构造函数 ,专门用于类对象的初始化(“构造”)。我们倾向于使用{}来标记初始化列表,因为它很清晰地表明初始化(构造)过程何时完成,而且这种方式用途更广。比如,还可以用于内置类型的初始化:
int x{7};

保持细节私有性

我们在设计类型时,设法保证合法值。即,我们隐藏类描述,提供一个创建合法对象的构造函数,所有成员函数的设计也遵循接受合法值、生成合法值的原则。对象的值通常称为状态,因此,合法值的思想通常被称为对象的合法状态。

定义成员函数

人们把公有接口放在类的开始,是因为接口是大多数人最感兴趣的。编译器并不关心函数和数据成员的顺序。当我们在类外定义一个成员时,需要指明它是哪个类的成员,这可通过class_name::member_name方式来实现:

Date::Date(int yy,int mm,int dd)    //构造函数
     :y{yy},m{mm},d{dd}             //注意:成员初始化
{
}

符号:y{yy},m{mm},d{dd}就是类成员初始化的语法,称为初始化列表。当然也可以这样写:

Date::Date(int yy,int mm,int dd)    //构造函数
{
    y=yy;
    m=mm;
    d=dd;
}

但最后一种写法,原则上讲,是先用默认值对成员进行了初始化,然后又对它们进行了赋值。而且这种写法的一个潜在问题是,我们有可能无意地在成员初始化之前使用它们。:y{yy},m{mm},d{dd}这种方式更直接地表达了我们的意图。两种写法之间的区别与下面两段代码之间的区别是一样的:

int x;      //首先定义变量x
//...
x=2;        //后来再给x赋值

和

int x{2};   //定义并初始化为2

我们也可以直接在类定义中定义成员函数:

//简单Date类(有些人习惯将实现细节放在最后)
class Date{
public:
    Date(int yy,int mm,int dd)
        :y{yy},m{mm},d{dd}
    {
        //...
    }
    void add_day(int n)
    {
        //...
    }
    int month() { return m; }
    
    //...
private:
    int y,m,d;
};

但这样会使类声明变得大而“凌乱”。我们不会在类声明中定义大的函数,对于简单的、较小的函数,我们应该考虑直接在类声明中给出其定义。注意,month()可以访问定义在其后(下)的m。实际上,类成员对其他成员的访问并不依赖于成员在类中的声明位置。
将成员函数的定义放在类定义内有两个作用:

  • 函数将成为内联的,即编译器为此函数的调用生成代码时,不会生成真正的函数调用,而是将其代码嵌入到调用者的代码中。对于month()这种所做工作很少,又被频繁调用的函数,这种编译方式会带来恨得的性能提升。
  • 每当我们对内联函数体做出修改时,所有使用这个类的程序都不得不重新编译。如果函数体位于类声明之外,就不必这样,只有类接口改变时才需要重新编译用户程序。对于大程序来说,函数体改变时无须重新编译程序会是一个巨大的优势。
  • 类定义变大了。因此,在成员函数定义中找到成员会变得困难。

显然,我们应遵循如下基本原则:除非你明确需要从小函数的内联中获得性能提升,否则不要将成员函数体放在类声明中。5行以上代码的函数不会从内联中获益,并且还使得类声明可读性差。

引用当前对象

每个类成员函数,都有一个隐式参数,用来识别调用它的对象。(this指针)

报告错误

放置检查代码的位置显然应该是我们最初构造一个Date对象时。如果没有创建非法的Date对象,而且成员函数也编写正确,那么我们就永远不会得到具有非法值的Date对象。因此,我们应该阻止用户创建具有非法状态的Date对象:

//简单Date类(有些人习惯将实现细节放在最后)
class Date{
public:
    class Invalid {};               //用于异常
    Date(int yy,int mm,int dd);     //检查日期合法性并初始化
    //...       
private:
    int y,m,d;                      //年、月、日
    bool is_valid();                //如果日期合法,则返回true
};

我们将合法性检查代码放到一个独立的函数is_valid()中,这一方面是因为,从逻辑上讲,合法性检查与初始化就是不同的工作,另一方面是因为,我们可能需要多个构造函数。

Date::Date(int yy,int mm,int dd)
     :y{yy},m{mm},d{dd}                     //初始化数据成员
{
    if(!is_valid())  throw Invalid{};       //检查合法性
}     

bool Date::is_valid()                       //如果日期
{
    if(m<1||m>12) return false;
    //...
}

给出这样的Date定义后,我们可以写出如下的代码:

void f(int x,int y)
try{
    Date dxy{2004,x,y};
    cout<<dxy<<endl;
    dxy.add_day(2);
}
catch(Date::Invalid){
    error("invalid date");
}

枚举类型

枚举是一种非常简单的用户自定义类型,它指定一个值的集合,这些值用符号常量表示,称为枚举量。

作用域枚举

enum class Month{
    jan=1,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec
};

enum class中的class表示枚举量在枚举作用域内,也就是说,必须用Month::jan来表示jan。我们可以为枚举量指定特定的值,就想上面代码为jan指定值一样。也可以不指定,让编译器选择合适的值。如果让编译器来选择值,它赋予每个枚举量的值为上一个枚举量的值加上1。如果我们不初始化第一个枚举量,那么编译器会从0开始计数。
我们可以像下面代码那样使用Month:

Month m=Month::feb;         
Month m2=feb;               //错误:feb不在作用域内
m=7;                        //错误:不能对Month赋int值
int n=m;                    //错误:不能对int赋Month值
Month mm=Month(7);          //将整型值转换为Month(不检查)
int x=int(Month::jan);      //将Month转换为整型值

“平坦”枚举

“平坦”枚举和作用域枚举的区别是,平坦枚举将它的枚举量都隐式导出到枚举类型所在的作用域里,并且可以隐式转换到int型。例如:

enum Month{                 //注意:此处没有“class”
    jan=1,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec
};

Month m=feb;                //正确:feb在该作用域内
Month m2=Month::feb;        //同样正确
m=7;                        //错误:不能对Month赋int值
int n=m;                    //正确:可以对int赋Month值
Month mm=Month(7);          //将整型值转换为Month(不检查)

我们倾向于使用更简单、更安全的作用域枚举类型,少用平坦枚举类型。

运算符重载

你可以在类或枚举对象上定义几乎所有C++运算符,这通常称为运算符重载。这种机制用于为用户自定义类型提供习惯的符号表示方法。如下例:

Month operator++(Month& m)
{
    m=(m==dec)?jan:Month(int(m)+1);
    return m;
}
vector<string>month_tbl;

ostream& operator<<(ostream& os,Month m)
{
    return os<<month_tbl[int(m)];
}

这里假定month_tbl已经在其他位置进行了初始化,每个数组元素保存了对应月份的恰当的名字,如month_tbl [int(Month::mar)] 的值为字符串“March”或其他合适的名字。
C++不能定义新的运算符,而且,重载运算符时,运算对象数目也必须与原来一样,例如,你可以定义一元运算符-,但不能定义一元的<=,你可以定义二元运算符+,但不能定义二元的!。并且,一个重载的运算符必须作用于至少一个用户自定义类型的运算对象:

int operator+(int,int);                         //错误:不能重载内置类型+运算符
vector operator+(const vector&,const vector&);  //正确
vector operator+=(const vector&,int);           //正确

一般性的原则是:除非你真正确定重载运算符能大大改善代码,否则不要为你的类型定义运算符。而且,运算符应该保持其原有意义:+就应该是加法,[ ]表示元素访问,()表示调用,等等。注意,不像大家一般猜想的那样,重载最多的运算符不是+、-、*、/,而是=、==、!=、<、[ ](下标运算符)及()(函数调用运算符)。

类接口

类的公有接口和实现部分应该分离。好的类接口有以下原则:

  • 保持接口的完整性
  • 保持接口的最小化
  • 提供构造函数
  • 支持(或者禁止)拷贝
  • 使用类型来提供完善的参数检查
  • 识别不可修改的成员函数
  • 在析构函数中释放所有资源

参数类型

我们在类名、枚举名或名字空间名后使用::,而在对象名后使用.(点)。
我们使用static限定一个类成员,可以保证它在整个程序中只有一份拷贝,而不是每个类对象都有一份。

拷贝

对象的拷贝的含义很简单———只要复制所有成员即可。实际上,这正是默认情形。只要你不特别声明,编译器就会正确地做到上述效果。也可以定义自己的拷贝函数(参见13章),或者将拷贝构造函数和拷贝赋值运算符描述为delete(参加19章)。

默认构造函数

对于类型T,符号T{}表示默认值,这是通过定义默认构造函数实现的,因此,我们可以写出下面这样的代码:

string s1=string{};               //默认值:空字符串
vector<int>v1=vector<int>{};      //默认值:空vector,没有元素

但是,我们更倾向于采用下面这种等价的,但更“口语化”的语法形式:

string s1;                      //默认值:空字符串
vector<int>v1;                  //默认值:空vector,没有元素

对于内置类型,如int和double来说,默认构造函数的结果为0,即,int{}是0的一种复杂描述,而double{}是0.0的一种啰嗦的说法。
使用默认构造函数不只是形式上的问题,它有着更深层次的重要作用。设想一下,若我们有一个未初始化的string或vector对象:

string s;
for(int i=0;i<s.size();i++)     //噢!循环次数未知
    s[i]=toupper(s[i]);         //噢!读写一个随机的内存位置

vector<string>v;
v.push_back("bad");             //噢!写入一个随机地址

如果s和v的值真的是未定义的话,我们就完全不知道它们包含多少个元素或者无法知道这些元素存放在哪里。其结果就是我们可能会访问随机地址——这会导致最麻烦的一类错误。基本上,没有构造函数的话,我们就无法建立一个不变式——也就不能保证变量中的值是合法的。我们必须坚持对变量进行初始化,最好的办法是定义一个构造函数,不需要程序员显式提供初始化代码,就能创建对象。这种构造函数不接受参数,我们称之为默认构造函数 。

class Date{
public:
    //...
    Date();
    //...
private:
    int y;
    Month m;
    int d;
};

Date::Date()
     :y{2001},m{Month::jan},d{1}
{
}

若不将成员默认值放在构造函数里,我们也可以将它们放在成员本身声明处:

class Date{
public:
    //...
    Date();                     //默认构造函数
    Date(year,Month,day);
    Date(int yy);                //yy年1月1日
    //...
private:
    int y{2001};
    Month m{Month::jan};
    int d{1};
};

这样的话,每个构造函数都可以使用默认值。例如:

Date::Date(int yy)
     :y{yy}
{
    if(!is_valid())  throw Invalid{};
}

因为Date(int)没有显式初始化月(m)和日(d),所以隐式使用了指定的初始化值。一个类成员在声明时指定的初始化值被称为类内初始化值 。
如果不想把默认值写入构造函数的代码中,我们可以使用一个常量(或一个变量)。

const Date& default_date()
{
    static Date dd{2001,Month::jan,1};
    return dd;
}

有了default_date(),为Date创建一个默认构造函数就很简单了:

Date::Date()
     :y{default_date().year()},
      m{default_date().month()},
      d{default_date().day()}
{
}

const成员函数

考虑下面代码:

void some_function(Date& d,const Date& start_of_term)
{
    int a=d.day();                  //可以
    int b=start_of_term.day();      //不可以(为什么不可以?)
    d.add_day(3);                   //可以
    start_of_term.add_day(3);       //错误
}

因为编译器不知道day()是否修改了对象的日期。我们没有给出过这方面的任何信息,因此编译器应该假定day()有可能修改日期,并报告一个错误。
我们可以将类操作划分为两类——可更改的和不可更改的,这样就可以解决这个问题。不修改对象的操作可以在对象上调用。如下例:

class Date{
public:
    //常量成员:不改变对象
    int day() const;
    Month month() const;
    int year() const;
    
    //非常量成员:可以改变对象
    void add_day(int n);
    void add_month(int n);
    void add_year(int n);
private:
    int y;
    Month m;
    int d;
};

Date d{2000,Month::jan,20};
const Date cd{2001,Month::feb,21};

cout<<d.day()<<"-"<<cd.day()<<endl;         //正确
d.add_day(1);                               //正确
cd.add_day(1);                              //错误:cd是常量

在一个成员函数声明中,我们将const放置参数列表右边,就表示这个成员函数可以在一个常量对象上调用。一旦将一个成员函数声明为const,编译器会帮助我们保证这个成员函数不会修改对象。例如:

int Date::day() const
{
    ++d;             //错误:试图从常量成员函数中改变对象
    return d;
}

类成员和“辅助函数”

如果一个函数可以简单、优美、高效地实现为一个独立函数时(即实现为非成员函数),就应该将它的实现放在类外。采用这种方式,函数中的错误就不会直接破坏类对象中的数据。如果类表示改变,只有直接访问类表示的函数才需要重写。这是保持接口最小化的另一个重要原因。
辅助函数还被称为便利函数、帮助函数等。这类函数和其他非成员函数在逻辑上是有区别的——辅助函数是一种设计思想,而不是一种编程概念。辅助函数通常接受一个类对象作为其参数,它就是为这个类做辅助工作。当然也有例外,参考leapyear()。我们通常用名字空间来区分一组辅助函数。

namespace Chrono{
    enum class Month{/*...*/};
    class Date{/*...*/};
    bool is_date(int y,Month m,int d);
    Date next_Sunday(const Date& d){/*...*/}
    Date next_weekend(const Date& d){/*...*/}
    bool leapyear(int y){/*...*/}
    bool operator==(const Date&a,const Date&b){/*...*/}
    //...
}

评论

暂无评论