菜鸟的C++ 知识盲区（跌倒）到知识发现（爬起）---------第七章 类

   前一部分好多都是讲语法的，基本偏C，没有涉及到类的描述。这一章，写一下关于面向对象的重点，就是类！！类这个东西是面向过程C语言中没有的东西，是面向对象的一个最大的东西。基本所有的语法都会围绕这个东西，在这里我只把自己认为比较容易漏的知识点写一下。

    以下这段话建议大家读十遍：  类的基本思想是数据抽象(data abstraction)和封装(encapsulation)。数据抽象是一种依赖于接口(interface)和实现(implementation)分离的编程（以及设计）技术。类的接口包括用户所能执行的操作：类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分。类要想实现数据抽象和封装，需要首先定义一个抽象数据类型(abstract data type)。在抽象数据类型中，由类的设计者负责考虑类的实现过程；使用该类的程序员则只需要抽象地思考类型做了什么，而无须了解类型的工作细节。

7.1.2定义改进的Sales_data类：

所有的成员函数必须在类内部声明，但是定义可以在类的外部和类的内部定义。先看Salas_data类的函数isbn：关于isbn函数一件有意思的事情是：它是如何获得bookNo成员所依赖的对象的呢？

std::string isbn() const { return bookNo; }

简而言之，成员函数就是通过一个名为 this的额外隐式参数来访问调用它的那个对象。但是，在成员函数内部，在成员函数内部，我们可以直接使用调用该函数的对象的成员，而无须通过成员访问运算符来做到这一点，因为this所指的正是这个对象。任何对类成员的直接访问都被看作this的隐式引用，也就是说，当isbn使用bookNo时，它隐式地使用this指向的成员，就像我们书写了this->bookNo一样。因为this的目的总是指向“这个"对象，所以this是一个常量指针（参见2，4．2 节，第56页），我们不允许改变this中保存的地址。

   isbn函数的另一个关键之处是紧随参数列表之后的const关键字，这里，const 的作用是修改隐式this指针的类型。默认情况下，this的类型是指向类类型非常量版本的常量指针。例如在sales data 成员函数中，this的类型是sales data虻。n豇。尽管this是隐式的，但它仍然需要遵循初始化规则，意味着（在默认情况下）我们不能把this绑定到一个常量对象上（参见2、42节，第56页）。这一情况也就使得我们不能在一个常量对象上调用普通的成员函数。如果isbn是一个普通函数而且this是一个普通的指针参数，则我们应该把this 声明成const Sales data *consto毕竟，在isbn的函数体内不会改变this所指的对象，所以把this设置为指向常量的指针有助于提高函数的灵活性。然而，this是隐式的并且不会出现在参数列表中，所以将this声明成指向常量的指针就成为我们必须面对的问题。c++语言的做法是允许把const关键字放在成员函数的参数列表之后，此时，紧跟在参数列表后面的const表示this是一个指向常量的指针。像这样使用const的成员函数被称作常量成员函数(constmemberfunction)o。可以把isbn的函数体想象成如下的形式：

std::string Sales_data::isbn(const Sales_data *const this){ return this->isbn; }

因为this是指向常量的指针，所以常量成员函数不能改变调用它的对象的内容。在上例中，isbn可以读取调用它的对象的数据成员，但是不能写入新值。说了这么多就想说下面这句话：所以所以！！！常量对象，以及常量对象的引用或者指针只能调用常量成员函数~。

     值得注意的是，即使bookNo定义在isbn之后，isbn也还是能够使用bookNoo 就如我们将在（第254页）学习到的那样，编译器分两步处理类：首先编译成员的声明，然后才轮到成员函数体（如果有的话）。因此，成员函数体可以随意使用类中的其他成员而无须在意这些成员出现的次序。

     ………………

7.1.4构造函数

 构造函数学过C++的人都知道了，就是初始化的一个过程函数。在这里再强调一遍：构造函数的任务是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数。构造函数的名字和类名相同。和其他函数不一样的是，构造函数没有返回类型：除此之外类似于其他的函数，构造函数也有一个（可能为空的）参数列表和一个（可能为空的）函数体。类可以包含多个构造函数，和其他重载函数差不多（参见6.4节，第206页），不同的构造函数之间必须在参数数量或参数类型上有所区别。不同于其他成员函数，构造函数不能被声明成const。当我们创建类的一个const对象时，直到构造函数完成初始化过程，对象才能真正取得其“常量"属性。因此，构造函数在const对象的构造过程中可以向其写值。

7.1.5拷贝、赋值和析构

       除了定义类的对象如何初始化之外，类还需要控制拷贝、赋值和销毁对象时发生的行一为。对象在几种情况下会被拷贝，如我们初始化变量以及以值的方式传递或返回一个对象等（参见621节，第187页和6.32节，第200页）。当我们使用了赋值运算符（参见4 4 节，第129页）时会发生对象的赋值操作。当对象不再存在时执行销毁的操作，比如一个局部对象会在创建它的块结束时被销毁（参见6．1.1节，第184页），当vector对象（或者数组）销毁时存储在其中的对象也会被销毁。

      尽管编译器能替我们合成拷贝、赋值和销毁的操作，但是必须要清楚的一点是，对于某些类来说合成的版本无法正常工作。特别是，当类需要分配类对象之外的资源时，合成的版本常常会失效。举个例子，第12章将介绍c++程序是如何分配和管理动态内存的。在（第447页）我们将会看到，管理动态内存的类通常不能依赖于上述操作的合成版本。

 7.2访问控制与封装

到目前为止，我们己经为类定义了接口，但并没有任何机制强制用户使用这些接口。我们的类还没有封装，也就是说，用户可以直达Sales data对象的内部并且控制它的具体实现细节。在C++语言中，我们使用访问说明符(access specifiers)加强类的封装性： pubulic  protect  private 等。另外class和struct的唯一区别就是默认访问权限的区别，struct的默认访问权限是private，而class是public。

类可以允许其他或者成员函数访问它的非公有成员，方法是令其他类或者函数成为它的友元。

Sales_data类的非成员组成部分声明：

Sales data add (const Sales data&, const Sales data&) ;

std：：istream &read(std：：istream&, Sales data&);

std：：ostream &print (std：：ostream&' const Sales data&);

class Sales_data {
// friend declarations for nonmember Sales_data operations added
friend Sales_data add(const Sales_data&, const Sales_da
friend std::istream &read(std::istream&, Sales_data&);
friend std::ostream &print(std::ostream&, const Sales_d
// other members and access specifiers as before
public:
Sales_data() = default;
Sales_data(const std::string &s, unsigned n, double
bookNo(s), units_sold(n), revenue(p*n)
Sales_data(const std::string &s): bookNo(s) { }
Sales_data(std::istream&);
std::string isbn() const { return bookNo; }
Sales_data &combine(const Sales_data&);
private:
std::string bookNo;
unsigned units_sold = 0;
double revenue = 0.0;
};
// declarations for nonmember parts of the Sales_data interface
Sales_data add(const Sales_data&, const Sales_data&);
std::istream &read(std::istream&, Sales_data&);
std::ostream &print(std::ostream&, const Sales_data&);

友元声明只能出现在类定义的内部，但是在类内出现的具体位置不限。友元不是类的成员也不受它所在区域访问控制级别的约束。友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明。如果我们希望类的用户能够调用某个友元数，那么我们就必须在友元声明之外再专门对函数进行一次声明。为了使友元对类的用户可见，我们通常把友元的声明与类本身放置在同一个头文件中（类的外部）。因此，我们的sales data头文件应该为read、print和add提供独立的声明（除了类内部的友元声明之外）。许多编译器并未强制限定友元函数必须在使用之前在类的外部声明.

我们的Sales data类把三个普通的非成员函数定义成了友元。类还可以把其他的类定义成友元，也可以把其他类（之前己定义过的）的成员函数定义成友元。此外，友元函数能定义在类的内部，这样的函数是隐式内联的。

class Screen {
// Window_mgr members can access the private parts of class Screen
friend class Window_mgr;
// ... rest of the Screen class
};
class Window_mgr {
public:
// location ID for each screen on the window
using ScreenIndex = std::vector<Screen>::size_type;
// reset the Screen at the given position to all blanks
void clear(ScreenIndex);
private:
std::vector<Screen> screens{Screen(24, 80, ' ')};
};
void Window_mgr::clear(ScreenIndex i)
{
// s is a reference to the Screen we want to clear
Screen &s = screens[i];
// reset the contents of that Screen to all blanks
s.contents = string(s.height * s.width, ' ');
}

如果clear不是screen的友元，上面的代码将无法通过编译，因为此时clear将不能访问Screen的height、width和contents成员。而当Screen将Window_mgr 指定为其友元之后，Screen的所有成员对于Window_mgr 就都变成可见的了。必须要注意的一点是，友元关系不存在传递性。也就是说，如果Window mgr有它自己的友元，则这些友元并不能理所当然地具有访问Screen的特权。

当然也可以使得某个类中的某个函数作为友元：要想令某个成员函数作为友元，我们必须仔细组织程序的结构以满足声明和定义的彼此依赖关系。在这个例子中，我们必须按照如下方式设计程序：

class Screen {
// Window_mgr::clear must have been declared before class Screen
friend void Window_mgr::clear(ScreenIndex);
// ... rest of the Screen class
};

• 首先定义Window mgr类，其中声明clear函数，但是不能定义它。在clear 使用Screen的成员之前必须先声明Screen
•  接下来定义Screen,包括对于clear的友元声明。
• 最后定义clear，此时它才可以使用screen的成员。

关于友元类的作用域使用说明见以下例子：

struct X {
friend void f() { /* friend function can be defined in the class
body */ }
X() { f(); } // error: no declaration for f
void g();
void h();
};
void X::g() { return f(); } // error: f hasn't been declared
void f(); // declares the function defined inside X
void X::h() { return f(); } // ok: declaration for f is now in scope

类和非成员函数的声明不是必须在它们的友元声明之前。当一个名字第一次出现在一个友元声明中时，我们隐式地假定该名字在当前作用域中是可见的。然而，友元本身不一定真的声明在当前作用域中。甚至就算在类的内部定义该函数，我们也必须在类的外部提供相应的声明从而使得函数可见。换句话说，即使我们仅仅是用声明友元的类的成员调用该友元函数，它也必须是被声明过的。

7.3类的其他特性

7.3.1返回*this的成员函数

废话不多说先看代码在分析：

class Screen {
public:
Screen &set(char);
Screen &set(pos, pos, char);
// other members as before
};
inline Screen &Screen::set(char c)
{
contents[cursor] = c; // set the new value at the current cursor location
return *this; // return this object as an lvalue
}
inline Screen &Screen::set(pos r, pos col, char ch)
{
contents[r*width + col] = ch; // set specified location to given
value
return *this; // return this object as an lvalue
}

// move the cursor to a given position, and set that character
myScreen.move(4,0).set('#');

这个操作将在同一个对象上执行。在上面的表达式中，我们首先移动myScreen内的光标，然后设置myScreen的contents成员。也就是说，上述语句等价于：

myScreen.move(4,0);
myScreen.set('#');

如果我们令move和set返回Screen而非Screen&，则上述语句的行为将大不相同。在此例中等价于：

// if move returns Screen not Screen&
Screen temp = myScreen.move(4,0); // the return value would be copied
temp.set('#'); // the contents inside myScreen would be unchanged

假如当初我们定义的返回类型不是引用，则move的返回值将是*this的副本，因此调用set只能改变临时副本，而不能改变myScreen的值。（精髓）

7.3.2类类型

每个类定义了唯一的类型。对于两个类来说，即使它们的成员完全一样，这两个类也是两个不同的类型。例如：

struct First {
int memi;
int getMem();
};
struct Second {
int memi;
int getMem();
};
First obj1;
Second obj2 = obj1; // error: obj1 and obj2 have different types

就像可以把函数的声明和定义分离开来一样（参见6．1.2节，第186页），我们也能仅仅声明类而暂时不定义它：

Class Screen;                         / / screen类的声明

这种声明有时被称作前向声明(forward declaration),它向程序中引入了名字screen并且指明Screen是一种类类型。对于类型Screen来说，在它声明之后定义之前是一个不完全类型(Incomplete type),也就是说，此时我们己知Screen是一个类类型，但是不清楚它到底包含哪些成员。不完全类型只能在非常有限的情景下使用：可以定义指向这种类型的指针或引用，也可以声明（但是不能定义）以不完全类型作为参数或者返回类型的函数。对于一个类来说，在我们创建它的对象之前该类必须被定义过，而不能仅仅被声明。否则，编译器就无法了解这样的对象需要多少存储空间。类似的，类也必须首先被定义，然后才能用引用或者指针访问其成员。毕竟，如果类尚未定义，编译器也就不清楚该类到底有哪些成员。直到类被定义之后数据成员才能被声明成这种类类型。换句话说，我们必须首先完成类的定义，然后编译器才能知道存储该数据成员需要多少空间。因为只有当类全部完成后类才算被定义，所以一个类的成员类型不能是该类自己。然而，一旦一个类的名字出现后，它就被认为是声明过了（但尚未定义），因此类允许包含指向它自身类型的引用或指针。

7.4类的作用域

每个类都会定义它自己的作用域。在类的作用域之外，普通的数据和函数成员只能山对象、引用或者指针使用成员访问运算符来访问。对于类类型成员则使用作用域运算符访问。不论哪种情况，跟在运算符之后的名字都必须是对应类的成员：

Screen::pos ht = 24, wd = 80; // use the pos type defined by Screen
Screen scr(ht, wd, ' ');
Screen *p = &scr;
char c = scr.get(); // fetches the get member from the object scr
c = p->get(); // fetches the get member from the object to which p

一个类就是一个作用域的事实能够很好地解释为什么当我们在类的外部定义成员函数时必须同时提供类名和函数名。在类的外部，成员的名字被隐藏起来了。

一般来说，内层作用域可以重新定义外层作用域中的名字，即使该名字己经在内层作用域中使用过。然而在类中，如果成员使用了外层作用域中的某个名字，而该名字代表一一种类型，则类不能在之后重新定义该名字：

typedef double Money;
string bal;
class Account {
public:
Money balance() { return bal; }
private:
typedef double Money; // error: cannot redefine Money
Money bal;
// ...
};

书中还有很多其他我认为不重要的东西，在这不说了。

7.5构造函数

7.5.1 构造函数初始值列表

有时我们可以忽略数据成员初始化和赋值之间的差异，但并非总能这样。如果成员是 const或者是引用的话，必须将其初始化。类似的，当成员属于某种类类型且该类没有定义默认构造函数时，也必须将这个成员初始化。例如：

class ConstRef {
public:
ConstRef(int ii);
private:
int i;
const int ci;
int &ri;
}

和其他常量对象或者引用一样，成员ci和ri都必须被初始化。因此，如果我们没有为它们提供构造函数初始值的话将引发错误：

// error: ci and ri must be initialized
ConstRef::ConstRef(int ii)
{ // assignments:
i = ii; // ok
ci = ii; // error: cannot assign to a const
ri = i; // error: ri was never initialized
}

随着构造函数体一开始执行，初始化就完成了。我们初始化const或者引用类型的数据成员的唯一机会就是通过构造函数初始值，因此该构造函数的正确形式应该是：

ConstRef::ConstRef(int ii): i(ii), ci(ii), ri(i) { }

如果成员是const、引用，或者属于某种未提供默认构造函数的类类型，我们必须通过构造函数初始值列表为这些成员提供初值。

还有一个类中只能有一个默认构造函数，默认构造函数就是没有形参或者形参都是默认值的构造函数。

C++ 11新标准扩展了构造函数初始值的功能，使得我们可以定义所谓的委托构造函数 (delegatingconstructor)。一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程，或者说它把它自己的一些（或者全部）职责委托给了其他构造函数。这里加将不介绍，平时用的很少，感兴趣的同志可以去看书里261页。

关于隐式的类类型转换听得挺绕口，是从 构造函数形参类型 到 该类类型 的一个编译器的自动转换。其实主要是因为类里面有转换构造函数，能通过一个实参调用的构造函数定义了一条从构造函数的参数类型向类类型隐式转换的规则。直接看代码吧：

#include "stdafx.h"
#include <string>
#include <iostream>
using namespace std ;
class BOOK  //定义了一个书类
{
    private:
        string _bookISBN ;  //书的ISBN号
        float _price ;    //书的价格

    public:
        //定义了一个成员函数，这个函数即是那个“期待一个实参为类类型的函数”
        //这个函数用于比较两本书的ISBN号是否相同
        bool isSameISBN(const BOOK & other ){
            return other._bookISBN==_bookISBN;
                }

        //类的构造函数，即那个“能够用一个参数进行调用的构造函数”（虽然它有两个形参，但其中一个有默认实参，只用一个参数也能进行调用）
        BOOK(string ISBN,float price=0.0f):_bookISBN(ISBN),_price(price){}
};

int main()
{
    BOOK A("A-A-A");
    BOOK B("B-B-B");

    cout<<A.isSameISBN(B)<<endl;   //正经地进行比较，无需发生转换

    cout<<A.isSameISBN(string("A-A-A"))<<endl; //此处即发生一个隐式转换：string类型-->BOOK类型，借助BOOK的构造函数进行转换，以满足isSameISBN函数的参数期待。
    cout<<A.isSameISBN(BOOK("A-A-A"))<<endl;    //显式创建临时对象，也即是编译器干的事情。
    
    system("pause");
}

 代码中可以看到，isSameISBN函数是期待一个BOOK类类型形参的，但我们却传递了一个string类型的给它，这不是它想要的啊！还好，BOOK类中有个构造函数，它使用一个string类型实参进行调用，编译器调用了这个构造函数，隐式地将stirng类型转换为BOOK类型（构造了一个BOOK临时对象），再传递给isSameISBN函数。

　　隐式类类型转换还是会带来风险的，正如上面标记，隐式转换得到类的临时变量，完成操作后就消失了，我们构造了一个完成测试后被丢弃的对象。我们可以通过explicit声明来抑制这种转换:

explicit BOOK(string ISBN,float price=0.0f):_bookISBN(ISBN),_price(price){}

而当我们用explicit关键字声明构造函数时，它将只能以直接初始化的形式使用。而且，编泽器将不会在自动转换过程中使用该构造函数 。

// ok: the argument is an explicitly constructed Sales_data object
item.combine(Sales_data(null_book));
// ok: static_cast can use an explicit constructor
item.combine(static_cast<Sales_data>(cin));

7.5.2 聚合类

聚合类(aggregate class)使得用户可以直接访问其成员，并且具有特殊的初始化语法形式。当一个类满足如下条件时，我们说它是聚合的：

 所有成员都是public的。

·没有定义任何构造函数。

·没有类内初始值（参见2五1节，第64页）。

没有基类，也没有virtual函数，关于这部分知识我们将在第15章详细介绍。

struct Data {
int ival;
string s;
};

我们可以提供一个花括号起来的成员初始值列表，并用它初始化聚合类的数据成员，且初始值的顺序必须和声明顺序一致。如果初始值列表中的元素个数少于类的成员数量，则靠后的成员被值初始化。初始值列表的元素个数绝对不能超过类的成员数量

// val1.ival = 0; val1.s = string("Anna")
Data val1 = { 0, "Anna" };

7.5.3字面值常量类

我们提到过constexpr函数的参数和返回值必须是字面值类型，除了算术类型、引用和指针外，某些类也是字面值类型。和其他类不同，字面值类型的类可能含有constexpr函数成员。这样的成员必须符合constexpr函数的所有要求，它们是隐式const的。

数据成员都是字面值类型的聚合类是字面值常量类。如果一个类不是聚合类，但它符合下述要求，则它也是一个字面值常量类：

• 数据成员都必须是字面值类型。
• 类必须至少含有一个constexpr构造函数
• 如果一个数据成员含有类内初始值，则内置类型成员的初始值必须是一条常量表达式；或者如果成员属于某种类类型，则初始值必须使用成员自己的constexpr构造函数。
• 类必须使用析构函数的默认定义，该成员负责销毁类的对象。

constexpr构造函数

尽管构造函数不能是const的，但是字面值常量类的构造函数可以是constexpr函数。事实上，一个字面值常量类必须至少提供一个constexpr构造函数。

constexpr构造函数可以声明成=default的形式（或者删除函数的形式）。否则，constexpr构造函数就必须既符合构造函数的要求（意味着不能包含返回语句），又符合constexpr函数的要求（意味着它能拥有的唯一可执行语句就是返回语句）。综合这两点可知，constexpr构造函数体一般来说应该是空的。我们通过前置关键字constexpr就可以声明一个constexpr构造函数了：

class Debug{
public:
    constexpr Debug(bool b=true):hw(b),io(b),other(b) {}
    constexpr Debug(bool h,bool i,bool o):hw(h),io(i),other(o)　{}
    constexpr bool any() {return hw||io||other;}
    void set_io(bool b) {io=b;}
    void set_hw(bool b) {hw=b;}
    void set_other(bool b) {hw=b;}
private:
    bool hw;
    bool io;
    bool other;
};

7.6类的静态成员

有的时候类需要它的一些成员与类本身直接相关，而不是与类的各个对象保持关联。例如，一个银行账户类可能需要一个数据成员来表示当前的基准利率。在此例中，我们希望利率与类关联，而非与类的每个对象关联。从实现效率的角度来看，没必要每个对象都存储利率信息。而且更加重要的是，一旦利率浮动，我们希望所有的对象都能使用新值。我们通过在成员的声明之前加上关键字static使得其与类关联在一起。静态数据成员的类型可以是常量、引用、指针、类类型等。举个例子：

class Account {
public:
void calculate() { amount += amount * interestRate; }
static double rate() { return interestRate; }
static void rate(double);
private:
std::string owner;
double amount;
static double interestRate;
static double initRate();
};

类似的，静态成员函数也不与任何对象绑定在一起，它们不包含this指针。作为结果，静态成员函数不能声明成const的，而且我们也不能在static函数体内使用this 指针。这一限制既适用于this的显式使用，也对调用非静态成员的隐式使用有效。

和其他的成员函数一样，我们既可以在类的内部也可以在类的外部定义静态成员函数。当在类的外部定义静态成员时，不能重复static关键字，该关键字只出现在类内部的声明语句：和类的所有成员一样，当我们指向类外部的静态成员时，必须指明成员所属的类名。static关键字则只出现在类内部的声明语句中。

class test
{
public:
    static int a;
};

int test::a = 4; // 一般的静态成员在类定义外初始化

其实是分配内存罢了。 

特殊的静态常量成员，可以在类内初始化，如下所示

class test
{
public:
    static const int a = 5;
};

const int test::a; // 注意，此处成员定义非必需，可有可无，但是不能再次初始化

另外静态成员函数中不能引用非静态成员。

lass Point  
{  
public:   
    void init()  
    {    
    }  
    static void output()  
    {  
        printf("%d\n", m_x);  
    }  
private:  
    int m_x;  
};  
void main()  
{  
    Point pt;  
    pt.output();  
}  
编译出错：error C2597: illegal reference to data member 'Point::m_x' in a static member function

因为静态成员函数属于整个类，在类实例化对象之前就已经分配空间了，而类的非静态成员必须在类实例化对象后才有内存空间，所以这个调用就出错了，就好比没有声明一个变量却提前使用它一样。

这一章就写到这里吧~