《C++primer学习笔记》——第7章类

蔚落 2022-11-03 13:29 50阅读 0赞

类的基本思想是**数据抽象(data abstraction)和封装(encapsulation)**。数据抽象是一种依赖**接口(interface)** 和 \*\*实现(implementation)\*\*分离的编程技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。  
封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现的部分。  
类要想实现数据抽象和封装，需要首先定义一个 **抽象数据类型** 。

# 一、定义抽象数据类型 #

## 1.设计Sales\_data类 ##

Sales\_data的接口应该包含以下操作：  
一个isbn成员函数，用于返回对象的ISBN编号  
一个combine成员函数，用于将一个Sales\_data对象加到另一个对象上  
一个名为add的函数，执行两个Sales\_data对象的加法  
一个read函数，将数据从istream读入到Sales\_data对象中  
一个print函数，将Sales\_data对象的值输出到ostream

### 使用改进的Sales\_data类 ###

在实现之前先看看如何使用他们：

Sales_data total;
    if(read(cin,total))	//读入第一笔交易
    { 
       sales_data trans;//用于暂存读入交易
       while(read(cin,trans))//读入下一笔交易
       { 
       	if(total.isbn()==trans.isbn());//检查isbn
       		total.combine(trans);//更新total当前的值
       	else
       		print(cout,total)<<endl;//输出结果
       		total  = trans;//处理下一本书
       }
    }
    print(cout,total)<<endl;//输出最后一条交易
    }else{ 
    cerr<<"No data?"<<endl;//没有任何输入信息
    }

## 2.定义Sales\_data类 ##

需要实现bookNo，string类型，表示ISBN编号；units\_sold，unsigned类型，表示某本书的销量；以及revenue，double类型，表示这本书的总销售收入。如前所述，我们的类将包含两个成员函数：combine和isbn。此外，我们还将赋予Sales\_data另一个成员函数用于返回售出书籍的平均价格，这个函数被命名为avg\_price。因为avg\_price的目的并非通用，所以它应该属于类的实现的一部分，而非接口的一部分。  
成员函数的声明必须在类的内部，它的定义既可以在类的内部也可以在类的外部。作为接口组成部分的非成员函数，例如add，read和print等，他们的定义和声明都在类的外部。  
由此可知，改进的Sales\_data类应该如下所示：

struct Sales_data{ 
    std::string isbn() const{ return bookNo;}
    Sales_data& combine(const Sales_data&);
    double avg_price() const;
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
    };
    Sales_data add(const Sales_data&,const Slaes_data&);
    std::ostream &print(std::ostream&,const Sales_data&);
    std::istream &read(std::istream&,Sales_data&);

T I P 1 \\color\{\#FF0000\}\{TIP1\} TIP1：**定义在类内部的函数是隐式的inline函数**

### 定义成员函数 ###

尽管所有成员都必须在类的内部声明，但是成员函数体可以在类内也可以定义在内外，对于Sales\_data类来说，isbn函数定义在了类内，而combine和avg\_price定义在了类外。  
首先我们介绍isbn函数，它的参数列表为空，返回值是一个string对象  
std::string isbn const \{return bookNo;\}

### 引入this ###

我们对isbn成员函数调用使用total.isbn()，使用点运算符访问total对象的isbn成员。如果isbn指向Sales\_data的成员（例如bookNo），则它隐式地指向调用该函数的对象的成员。  
成员函数通过一个名为this的额外的隐式参数来访问调用它的那个对象。当我们调用一个成员函数时，用请求该参数的对象地址初始化this。例如调用total.isbn()编译器负责把total的地址传递给isbn的隐式形参this，可以邓加的认为编译器重写代码为：Sales\_data::isbn(&total)其中调用Sales\_data的isbn成员时传入了total的地址。在成员函数内部，我们可以直接使用调用该函数的对象的成员，而无须通过成员访问符来实现。当isbn使用bookNo时候，就隐式的使用this指向的成员，就像我们写了this->bookNo一样。  
std::string isbn const \{return bookNo;\}  
其实也就等价于  
std::string isbn const \{return this->bookNo;\}  
this是一个常量指针，我们不允许改变this中保存的地址。

### 引入const成员函数 ###

std::string isbn const \{return this->bookNo;\}  
isbn中另一个关键之处是const关键字。这里const的作用是修改隐式this指针的类型。默认情况下，this的类型是指向类类型非常量版本的常量指针。例如Sales\_data成员函数中，this类型是Sales\_data \*const。尽管this是隐式的，但它仍需要遵循初始化规则，也就是说我们不能把this绑定到一个常量对象上。  
这里把const关键字放在成员函数的参数列表之后，此时，紧跟在参数列表后面的const表示this是一个指向常量的指针。像这样使用const的成员函数被称为常量成员函数。

### 类作用域和成员函数 ###

即使bookNo定义在isbn后，isbn也还是能够使用bookNo，编译器分为两步处理类：首先编译成员声明，然后才轮到成员函数体。所以成员函数体可以随意使用类中的其他成员而无需考虑次序。

### 在类的外部定义成员函数 ###

如果在类的外部定义成员函数，成员函数必须与它的声明匹配。并且使用作用域运算符来说明作用域：

double Sales_data::avg_price() const{ 
    if(units_sold)
    return xxx;
    }

### 定义一个返回this对象的函数 ###

Slaes_data& Sales_data::combine(const Sales_data &rhs)
    { 
    	units_sold+=rhs.units_sold;
    	revenue+=rhs.revenue;
    	return *this;
    }
    调用如下：
    total.combine(trans);//更新total的值

combine设计的初衷是类似于复合赋值运算符+=。注意它的返回类型和返回语句。当我们定义的函数类似于某个内置运算符时，应该令该函数的行为尽量模仿这个运算符。内置的赋值运算符把左侧运算对象当成左值返回，因此combine函数必须返回引用类型。  
如前所示，我们要返回整个对象时候，使用this，而return语句解引用this指针以获得该函数的对象，上面这个调用返回total的引用。

## 3.定义相关的非成员函数 ##

从概念上add、read、print等函数属于类的接口组成部分，但它们实际上并不属于类本身。我们一般会把这些函数与类声明在同一个头文件内。在这种方式下，用户使用接口的任何部分都只需要引入一个文件。

### 定义read和print函数 ###

istream& read(istream&is ,Sales_data &item)
    { 	
    	double price = 0;
    	is>>item.bookNo>>item.units_sold>>price;
    	item.revenue = price*item.units_sold;
    	return is;
    }
    ostream& print(ostream &os, const Sales_data &item)
    { 
    	os<<item.isbn()<<" "<<item.units_sold<<" "
    	<<item.revenue<<" "<<item.avg_price();
    	return os;
    }

因为IO类属于不能被拷贝的类型，因此我们只能通过引用来传递它们

### 定义add函数 ###

Sales_data add(const Sales_data &lhs,const Sales_data &rhs)
    { 
    	Sales_data sum = lhs;
    	sum.combine(rhs);
    	return sum;
    }

## 4.构造函数 ##

类通过一个或几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做**构造函数**。构造函数的任务是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数。这里只介绍最基本的构造函数。后面还会详细介绍。  
**构造函数的名字和类名相同**,和其它函数不一样的是，构造函数没有返回类型。构造函数也可以有多个，原理就是函数重载。  
构造函数不能声明为const，直到构造函数完成初始化过程，对象才能真正取得其“常量”属性。因此，构造函数在const对象的构造过程中可以向其写值。

### 合成的默认构造函数 ###

不定义构造函数会使用默认构造函数。编译器会隐式的定义构造函数。  
 T I P 2 \\color\{\#FF0000\}\{TIP2\} TIP2：**合成的默认构造函数只适合非常简单的类，如果类包含有内置类型或者复合类型的成员，则只有当这些成员都被赋予了类内的初始值，这个类才适合于使用合成的默认构造函数**

### 定义Sales\_data的构造函数 ###

struct Sales_data{ 
    Sales_data() = default;
    Sales_data(const std::string &s) : bookNo(s){ }
    Sales_datata(const std::string &s, unsigned n, double p) : bookNo(s),units_sold(n),revenue(p*n){ }
    //....
    
    }

### =default的含义 ###

C++11中，如果我们需要默认的行为，可以在参数列表后面写上=default来要求编译器生成构造函数。

### 构造函数初始值列表 ###

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

### 在类的外部定义构造函数 ###

上面几个构造函数花括号中没有内容，因为只需要简单的赋值，但对于IO的读取则需要：

Sales_data::Sales_data(std::istream& is)
    { 
    	read(is,*this);
    }

注意，构造函数没有返回类型。

### 委托构造函数 ###

### 在类的外部定义构造函数 ###

istream为参数的构造函数需要执行一些实际的操作，在它的函数体内，调用了read函数

Sales_data::Sales_data(std::istream &is)
    { read(is,*this);}//read函数从is中读取一条交易信息然后存入this对象中

## 5.拷贝、赋值和析构 ##

除了定义类的对象如何初始化外，类还需要控制拷贝、赋值、销毁。编译器会人性化的实现拷贝：

total = trans;

第13章会讲解如何自定义上述操作。

# 二、访问控制与封装 #

我们还需要对类进行封装，不然用户可能不会直接使用这些接口，而是直达Sales\_data对象的内部并控制它的具体实现细节。在C++语言中，我们使用**访问说明符**来加强类的封装性。  
定义在**public**说明符之后的成员在整个程序内可被访问，public成员定义类的接口。  
定义在**private**说明符之后的成员可以被类的成员函数访问，但是不能使用该类的代码访问，private部分封装了类的实现细节

class Slaes_data{ 
    public:
    	Sales_data() = default;
    	Sales_data(const std::string &s) : bookNo(s){ }
    	Sales_datata(const std::string &s, unsigned n, double p) : 	bookNo(s),units_sold(n),revenue(p*n){ }
    private:
    	double avg_price() const{ return units_sold ? revenue/units_sold:0;}
    	std::string bookNo;
    	unsigned units_sold = 0;
    	double revenue = 0.0;
    }

作为接口的一部分，构造函数和部分成员函数紧跟在public说明符之后，而数据成员和作为实现部分的函数跟在private说明符后面。  
 T I P 3 \\color\{\#FF0000\}\{TIP3\} TIP3：**出于统一编程风格的考虑，当我们希望定义的类的所有成员是public时，使用struct。如果希望成员是private的，使用class。**

### 使用class或struct关键字 ###

**struct和class都可以定义类，唯一的区别是默认的访问权限不太一样** 类可以在它的第一个访问说明符之前定义成员，对这种成员的访问权限依赖于类定义的方式。如果我们使用struct关键字，则定义在第一个访问说明符之前的成员是public的，相反，如果我们使用class关键字，则这些成员是private的。

## 1、友元 ##

既然Sales\_data的数据成员是private的，我们的read、print和add函数也就无法正常编译了，这是因为尽管这几个函数是类的接口的一部分，但是它们不是类的成员。  
类可以允许其它类或者函数访问它的非公有成员，方法是让其它类或者函数成为它的**友元**只需要添加一条以friend关键字开始的**函数声明**语句即可:

class Slaes_data{ 
    friend Sales_data add(const Sales_data&,const Sales_data&);
    friend std::istream &read(std::istream&,Sales_data&);
    friend std::ostream &print(std::ostream&,const Sales_data&);
    public:
     Sales_data() = default;
     Sales_data(const std::string &s) : bookNo(s){ }
     Sales_datata(const std::string &s, unsigned n, double p) :  bookNo(s),units_sold(n),revenue(p*n){ }
    private:
     double avg_price() const{ return units_sold ? revenue/units_sold:0;}
     std::string bookNo;
     unsigned units_sold = 0;
     double revenue = 0.0;
    }

友元声明只能出现在类定义的内部，但是类内出现的具体位置不限。  
 T I P 4 \\color\{\#FF0000\}\{TIP4\} TIP4：**为什么要封装：一是确保用户代码不会无意间被封装对象破坏，二是被封装的类的具体实现细节可以随时改变，而无须调整用户级别的代码** 一旦把数据编程private，类的作者可以自由地修改数据，当实现部分改变时候，只需检查类本身的代码，只要接口不变，就不会对用户代码产生影响。另一个原因是可以防止由于用户的原因造成的数据被破坏。可以有限的范围内定位缺陷，极大的降低维护代码的难度。  
 T I P 5 \\color\{\#FF0000\}\{TIP5\} TIP5：**友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明，如果我们希望类的用户能够调用某个友元函数，那么我们就必须在友元声明之外再专门对函数进行一次声明。**

# 三、类的其它特性 #

## 1.类成员再探 ##

为了展示这些新特性，我们需要定义一对相互关联的类，它们分别是Screen和Window\_mgr。

### 定义一个类型成员 ###

下面做一个Screen表示显示器中的一个窗口，每个Screen包含一个用于保存Screen内容的string成员和三个string::size\_type类型的成员表示光标位置，显示屏长宽。

class Screen{ 
    public:
    	typedef std::string::size_type pos;
    	Screen() = default;
    	Screen(pos ht,pos wd,char c):height(ht),width(wd),contents(ht*wd,c){ }
    	char get() const{ return contents[cursor];}
    	inline char get(pos ht,pos wd) const;
    	Screen &move(pos r,pos c);
    private:
    	pos cursor=0;
    	pos height = 0,width = 0;
    	std::string contents;	
    };

如上述代码所示，类可以自定义某种类型在类中的别名，和其他成员一样，别名存在访问限制，可以是public或者private中的一种。同样的也可以使用using

### 令成员作为内联函数 ###

和普通的一样

### 重载成员函数 ###

和普通的一样

### 可变数据成员 ###

有时我们希望能修改类的某个数据成员，即使是在一个const成员函数内。可以通过在变量的声明中假如mutable关键字做到这一点：

private:
    	mutable size_t access_ctr;
    void Screen::some_member() const
    { 
    	++access_ctr;
    }

尽管some\_member是一个const成员函数，它仍然能够改变access\_ctr的值。该成员是个可变成员，因此任何成员函数，包括const函数在内都能改变它的值。

### 类数据成员的初始值 ###

就是说类A的某个成员是类B，初始化类B,应当使用C++11新标准中的类内初始值

class Window_mgr{ 
    private:
    	std::vector<Screen> screens{ Screen(24,80,' ')};
    }