C++拾遗（五）——类

　　类是 C++ 中最重要的特征。C++ 语言的早期版本被命名为“带类的 C（Cwith Classes）”，以强调类机制的中心作用。随着语言的演变，创建类的配套支持也在不断增加。语言设计的主要目标也变成提供这样一些特性：允许程序定义自己的类型，它们用起来与内置类型一样容易和直观。

类的定义和声明

• 类背后蕴涵的基本思想是数据抽象和封装。
• 数据抽象是一种依赖于接口和实现分离的编程（和设计）技术。类设计者必须关心类是如何实现的，但使用该类的程序员不必了解这些细节。相反，使用一个类型的程序员仅需了解类型的接口，他们可以抽象地考虑该类型做什么，而不必具体地考虑该类型如何工作。
• 封装是一项低层次的元素组合起来的形成新的、高层次实体珠技术。函数是封装的一种形式：函数所执行的细节行为被封装在函数本身这个更大的实体中。被封装的元素隐藏了它们的实现细节——可以调用一个函数但不能访问它所执行的语句。同样地，类也是一个封装的实体：它代表若干成员的聚焦，大多数（良好设计的）类类型隐藏了实现该类型的成员。
• 标准库类型 vector 同时具备数据抽象和封装的特性。在使用方面它是抽象的，只需考虑它的接口，即它能执行的操作。它又是封装的，因为我们既无法了解该类型如何表示的细节，也无法访问其任意的实现制品。另一方面，数组在概念上类似于 vector，但既不是抽象的，也不是封装的。可以通过访问存放数组的内存来直接操纵数组。
• 并非所有类型都必须是抽象的。标准库中的 pair 类就是一个实用的、设计良好的具体类而不是抽象类。具体类会暴露而非隐藏其实现细节。一些类，例如 pair，确实没有抽象接口。pair 类型只是将两个数据成员捆绑成单个对象。在这种情况下，隐藏数据成员没有必要也没有明显的好处。在像 pair 这样的类中隐藏数据成员只会造成类型使用的复杂化。
• 数据抽象和封装提供了两个重要优点：1.避免类内部出现无意的、可能破坏对象状态的用户级错误。2.随时间推移可以根据需求改变或缺陷（bug）报告来完美类实现，而无须改变用户级代码。

隐含的this指针

• 成员函数具有一个附加的隐含形参，即指向该类对象的一个指针。这个隐含形参命名为 this，与调用成员函数的对象绑定在一起。成员函数不能定义 this 形参，而是由编译器隐含地定义。成员函数的函数体可以显式使用 this 指针，但不是必须这么做。如果对类成员的引用没有限定，编译器会将这种引用处理成通过 this 指针的引用。
• 尽管在成员函数内部显式引用 this 通常是不必要的，但有一种情况下必须这样做：当我们需要将一个对象作为整体引用而不是引用对象的一个成员时。最常见的情况是在这样的函数中使用 this：该函数返回对调用该函数的对象的引用。
• 在普通的非 const 成员函数中，this 的类型是一个指向类类型的 const 指针。可以改变 this 所指向的值，但不能改变 this 所保存的地址。在 const 成员函数中，this 的类型是一个指向 const 类类型对象的const 指针。既不能改变 this 所指向的对象，也不能改变 this 所保存的地址。注意不能从 const 成员函数返回指向类对象的普通引用。const 成员函数只能返回 *this 作为一个 const 引用。.
• 有时，我们希望类的数据成员（甚至在 const 成员函数内）可以修改。这可以通过将它们声明为 mutable 来实现。可变数据成员（mutable data member）永远都不能为 const，甚至当它是const 对象的成员时也如此。因此，const 成员函数可以改变 mutable 成员。要将数据成员声明为可变的，必须将关键字 mutable 放在成员声明之前。

构造函数

• 构造函数是特殊的成员函数，只要创建类类型的新对象，都要执行构造函数。构造函数的工作是保证每个对象的数据成员具有合适的初始值。构造函数的名字与类的名字相同，并且不能指定返回类型。像其他任何函数一样，它们可以没有形参，也可以定义多个形参。构造函数可以被重载，实参决定使用哪个构造函数。构造函数自动执行。
• 构造函数不能声明为 const，创建类类型的 const 对象时，运行一个普通构造函数来初始化该 const 对象。构造函数的工作是初始化对象。不管对象是否为 const，都用一个构造函数来初始化化该对象。
• 构造函数初始化列表以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个数据成员后面跟一个放在圆括号中的初始化式。与任意的成员函数一样，构造函数可以定义在类的内部或外部。构造函数初始化只在构造函数的定义中而不是声明中指定。
• 如果没有为类成员提供初始化式，则编译器会隐式地使用成员类型的默认构造函数。如果那个类没有默认构造函数，则编译器尝试使用默认构造函数将会失败。在这种情况下，为了初始化数据成员，必须提供初始化式。有些成员必须在构造函数初始化列表中进行初始化。对于这样的成员，在构造函数函数体中对它们赋值不起作用。没有默认构造函数的类类型的成员，以及 const 或引用类型的成员，不管是哪种类型，都必须在构造函数初始化列表中进行初始化。
• 只要定义一个对象时没有提供初始化式，就使用默认构造函数。为所有形参提供默认实参的构造函数也定义了默认构造函数。一个类哪怕只定义了一个构造函数，编译器也不会再生成默认构造函数。这条规则的根据是，如果一个类在某种情况下需要控制对象初始化，则该类很可能在所有情况下都需要控制。只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。内置和复合类型的成员，如指针和数组，只对定义在全局作用域中的对象才初始化。当对象定义在局部作用域中时，内置或复合类型的成员不进行初始化。如果类包含内置或复合类型的成员，则该类不应该依赖于合成的默认构造函数。它应该定义自己的构造函数来初始化这些成员。

static类成员

• 不像普通的数据成员，static 数据成员独立于该类的任意对象而存在；每个 static 数据成员是与类关联的对象，并不与该类的对象相关联。正如类可以定义共享的 static 数据成员一样，类也可以定义 static 成员函数。static 成员函数没有 this 形参，它可以直接访问所属类的 static 成员，但不能直接使用非 static 成员。
• 使用static 成员而不是全局对象有三个优点。1. static 成员的名字是在类的作用域中，因此可以避免与其他类的成员或全局对象名字冲突。2. 可以实施封装。static 成员可以是私有成员，而全局对象不可以。3. 通过阅读程序容易看出 static 成员是与特定类关联的。这种可见性可清晰地显示程序员的意图。

一个实例

　　为了增进读者对上述文字的理解，这里给出一个实例，源自《C++ Primer》习题12.13：扩展Screen类以包含move、set和display操作通过执行如下表达式来测试类：

// 将光标移至指定位置，设置字符并显示屏幕内容 
myScreen.move(4,0).set('#').display(cout); 

　　答案如下：

#include <iostream> 
#include <string> 

using namespace std;

class Screen {
public:
    typedef string::size_type index;
    char get() const { return contents[cursor]; }
    inline char get(index ht, index wd) const;
    index get_cursor() const; 
    Screen(index hght, index wdth, const string &cntnts); 
    
    // 增加三个成员函数 
    Screen& move(index r, index c); 
    Screen& set(char);
    Screen& display(ostream &os); 

private: 
    std::string contents;
    index cursor; 
    index height, width;
}; 

Screen::Screen(index hght, index wdth, const string &cntnts) : 
        contents(cntnts), cursor(0), height(hght), width(wdth) { }

char Screen::get(index r, index c) const 
{ 
    index row = r * width; 
    return contents[row + c]; 
} 

inline Screen::index Screen::get_cursor() const 
{ 
    return cursor; 
} 

// 增加的三个成员函数的定义 
Screen& Screen::set(char c) 
{ 
    contents[cursor] = c; 
    return *this;
} 

Screen& Screen::move(index r, index c) 
{ 
    index row = r * width; 
    cursor = row + c; 
    return *this; 
} 

Screen& Screen::display(ostream &os) 
{ 
    os << contents; 
    return *this; 
} 

int main()
{
    // 根据屏幕的高度、宽度和内容的值来创建
    Screen Screen myScreen(5, 6, "aaaaa
aaaaa
aaaaa
aaaaa
aaaaa
");

    // 将光标移至指定位置，设置字符并显示屏幕内容 
    myScreen.move(4, 0).set('#').display(cout);

    return 0;
}

　　这个解决方法已满足了题目提出的要求，但存在一些缺陷：

　　(1) 创建Screen对象时必须给出表示整个屏幕内容的字符串，即使有些位置上没有内容。

　　(2) 显示的屏幕内容没有恰当地分行，而是连续显示，因此（4,0）位置上的'#'，在实际显示时 不一定正好在屏幕的（4,0）位置，显示效果较差。

　　(3) 如果创建的Screen对象是一个const对象，则不能使用display函数进行显示（因为const对 象只能使用const成员）。

　　(4) 如果move操作的目的位置超出了屏幕的边界，会出现运行时错误。 

　　要解决第一个缺陷，可以如下修改构造函数：

Screen::Screen(index hght, index wdth, const string &cntnts = " "): cursor(0), height(hght), width(wdth)
 { 
    // 将整个屏幕内容置为空格 
    contents.assign(hght*wdth, ' ');
     // 用形参string对象的内容设置屏幕的相应字符 
    if (cntnts.size() != 0) 
    　　contents.replace(0, cntnts.size(), cntnts); 
}    

　　要解决第二个缺陷，可以如下修改display函数：

Screen& Screen::display(ostream &os)
{ 
    string::size_type index = 0; 
    while (index != contents.size()) 
    { 
        os << contents[index];
         if ((index+1) % width == 0) 
        { 
            os << '
'; 
        } 
        ++index; 
    } 
    return *this; 
}        

　　要解决第三个缺陷，可以在Screen类定义体中增加如下函数声明： const Screen& display(ostream &os) const; 声明display函数的一个重载版本，供 const对象使用。
　　要解决第四个缺陷，可以如下修改move函数：

Screen& Screen::move(index r, index c) 
{ 
    // 行、列号均从0开始
    if (r >= height c >= width) 
    { 
        cerr << "invalid row or column" << endl; 
        throw EXIT_FAILURE;
    }

    index row = r * width;
    cursor = row + c; 
    return *this;
}         

　　经过如上述几处修改，整个程序的健壮性，鲁棒性都得到了改善。全部代码如下：

#include <iostream> 
#include <string> 

using namespace std; 

class Screen { 
public: 
    typedef string::size_type index; 
    char get() const { return contents[cursor]; } 
    inline char get(index ht, index wd) const; 
    index get_cursor() const; 
    
    Screen(index hght, index wdth, const string &cntnts);  
    
    Screen& move(index r, index c); 
    Screen& set(char); 
    Screen& display(ostream &os); 
    const Screen& display(ostream &os) const;

private: 
    std::string contents; 
    index cursor; 
    index height, width; 
}; 
    
Screen::Screen(index hght, index wdth, const string &cntnts = "1"): 
        cursor(0), height(hght), width(wdth) 
{ 
    contents.assign(hght*wdth, '1');

    if (cntnts.size() != 0)
        contents.replace(0, cntnts.size(), cntnts);
} 
    

char Screen::get(index r, index c) const 
{ 
    index row = r * width; 
    return contents[row + c]; 
} 
    
inline Screen::index Screen::get_cursor() const 
{ 
    return cursor; 
}  
    
Screen& Screen::set(char c) 
{ 
    contents[cursor] = c; 
    return *this; 
} 
    
Screen& Screen::move(index r, index c) 
{ 
    if (r >= height || c >= width)
    {
        cerr << "invalid row or column" << endl;
        throw EXIT_FAILURE;
    }

    index row = r * width; 
    cursor = row + c; 

    return *this; 
} 
    
Screen& Screen::display(ostream &os) 
{ 
    string::size_type index = 0;

    while (index != contents.size())
    {
        os << contents[index];
        if ((index + 1) % width == 0)
        {
            os << '
';
        }
        ++index;
    }
    return *this; 
} 

const Screen& Screen::display(ostream &os) const
{
    string::size_type index = 0;

    while (index != contents.size())
    {
        os << contents[index];
        if ((index + 1) % width == 0)
        {
            os << '
';
        }
        ++index;
    }
    return *this;
}
    
int main() 
{  
    Screen myScreen(10,30);
    //Screen myScreen(5, 6, "aaaaa
aaaaa
aaaaa
aaaaa
aaaaa
");
    myScreen.move(4, 0).set('#').display(cout);

    system("pause");

    return 0;
}