第7章 类

第7章 类

类的基本思想是数据抽象和封装。

数据抽象是一种依赖于接口和实现分离的编程技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。

封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就说，类的用户只能使用接口而无法访问实现部分。

类若想实现数据抽象和封装，需要首先定一个抽象数据类型。在抽象数据类型中，由类的设计者负责考虑类的实现过程；使用该类的程序员则只需要抽象地思考类型做了什么，而无须了解类型的工作细节。

7.1 定义抽象数据类型

7.1.4 构造函数

类定义了它的对象被初始化的方式，类通过一个或几个特殊的成员函数来控制其对象的初始过程，这些函数叫做构造函数。构造函数的任务是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数。

构造函数的特点：

特点
没有返回类型
名字和类名相同
有一个可能为空的参数列表和一个可能为空的函数体
构造函数可以进行重载

注！！！：构造函数不能被声明成const(静态成员函数)。当创建一个类的const的对象时，直到构造函数完成初始化过程，对象才能真正取得其"常量属性"。因此，构造函数在const对象的构造过程中可以向其写值。

合成的默认构造函数

若我们的类没有显式地定义构造函数，那么编译器就会为我们隐式地定义一个默认构造函数。编译器创建的构造函数又被称为合成的默认构造函数。

合成的默认构造函数按照以下规则初始化类的数据成员：若存在类内初始值，用它来初始化成员；否则，默认初始化该成员。

某些类不能依赖于合成的默认构造函数

合成的默认构造函数只适合非常简单的类。对于一个普通的类，必须定义自己的默认构造函数，原因如下：

原因
1、编译器在发现类不包含任何构造函数的情况下才会替我们生成一个默认的构造函数。一旦我们定义了其他构造函数，除非我们再定义一个默认的构造函数，否则类将没有默认构造函数。
2、对于某些类，合成的默认构造函数可能执行错误的操作。定义在块中的内置类型或复合类型的对象被默认初始化，它们的值是不确定的。
3、有时编译器无法合成默认的构造函数。若类中包含一个其他类类型的成员并且这个成员的类型没有默认构造函数，那么编译器无法初始化该成员。

构造函数初始值列表

Sales_data(const std::string &s):bookNo(s){}
Sales_data(const std::string &s,unsigned n,double p):bookNo(s),units_sold(n),revenue(p*n){}

上面代码段中冒号以及冒号和花括号之间的代码被称为构造函数初始值列表，它负责为新创建的对象的一个或几个数据成员赋初值。每个数据成员后面紧跟括号(或者花括号内的)的内容是成员初始值。不同成员的初始值用逗号隔开来。

7.2 访问控制与封装

访问说明符
public	public说明符之后的成员在整个程序内可被访问
private	private说明符之后的成员可以被类的成员函数访问，但是不能被使用该类的代码访问，private部分封装了类的实现细节

使用class和struct关键字

struct和class的默认访问权限不一样。

struct默认访问权限是public,class默认访问权限是private。

7.2.1 友元

类可以允许其他类或者函数访问它的非公有成员，方法是令其他类或者函数成为它的友元。若类想把一个函数作为它的友元，只需要增加一条friend关键字开始的函数声明语句。

注！！！：友元声明只能出现在类定义的内部，但是在类内出现的具体位置不限。

class Person{

friend istream &read(istream &is,Person &p);
friend ostream &print(ostream &os,const Person &p);

private:
    string name;
    string addr;
public:
    Person();
    Person(const string &s1,const string &s2);

    string getName() const;
    string getAddr() const;
};

7.3 类的其他特性

7.3.1 类成员再探

可变数据成员

有时我们希望能修改类的某个数据成员，即使是在一个const成员函数内。可以通过在变量的声明中加入mutable关键字做到这一点。例如，我们将给Person类添加一个名为access_ctr的可变成员，通过它我们可以追踪每个Person的成员函数被调用了多少次：

//.h
class Person{
private:  
    mutable size_t access_str;
public:
    Person();
    Person(const string &s1,const string &s2);

    string getName() const;
    string getAddr() const;

    int some_member() const;
};

//.cpp
int Person::some_member() const{
     return ++access_str;
}


int main(){
    Person p;
    int res=p.some_member();
    cout<<res<<endl; //调用1次，所以res=1
    return 0;
}

7.3.2 返回*this的成员函数

从const成员函数返回*this

注：一个const成员函数如果以引用的形式返回*this，那么它的返回类型将是常量引用。

const Person& display(...) const{
    ...
	return *this;
}

7.3.3 类类型与

类的声明

可以仅仅声明类而暂时不定义它：

class Person;//Person类的声明

这种声明被称作前向声明，在声明之前定义之后是一个不完全类型。

不完全类型可以定义指向这种类型的指针或引用，也可以声明(但是不能定义)以不完全类型作为参数或者返回类型的函数。

一旦一个类的名字出现后，它就被认为声明过了(但尚未定义)，因此类允许包含指向它自身类型的引用或指针：

class Person{
    string s;
    Person *next;
    Person *prev;
}

7.5 构造函数再探

7.5.1 构造函数初始值列表

//就对象的数据成员而言，初始化和赋值有区别
//初始化
Sales_data(const std::string &s,unsigned n,double p):bookNo(s),units_sold(n),revenue(p*n){
    
}

//赋值
Sales_data(const std::string &s,unsigned n,double p){
    bookNo=s;
    units_sold=n;
    revenue=n*p;   
}

构造函数完成后，类Sales_data的值相同。初始化和赋值区别的影响完全依赖于数据成员的类型。

构造函数的初始值有时必不可少

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

7.5.2 委任构造函数

C++11新标准拓展了构造函数初始值的功能，使得我们可以定义所谓的委任构造函数。一个委任构造函数使用它所属的类的其他构造函数执行它自己的初始化过程，或者它把它自己的一些(或者全部)职责委任给其他构造函数。

委任构造函数的成员初始值列表只有一个唯一的入口，也就是类名本身。类名后面紧跟圆括号起来的参数列表，参数列表必须与类中另外一个构造函数匹配。

class Person{
public:
    //非委托构造函数使用对应的实参初始化成员
    Person(const string &s1,const string &s2):name(s1),addr(s2){}
    //其余构造函数全都委托给另一个构造函数
    Person():Person("huruohai","hfut"){}
};

7.5.4 隐式的类类型转换

C++语言在内置类型之间定义了几种转换规则，同样的，也能为类定义隐式转换规则。若构造函数只接受一个实参或者仅有一个成员（第一个成员）未被初始化值列表中的参数初始化，则它实际上定义了转换为此类类型的隐式转换机制，有时我们把这种构造函数称作转换构造函数。

注！！！:能通过一个实参调用的构造函数定义了一条从构造函数的参数类型向类类型隐式转换的规则。

//addr初始值为""
Person::Person(const std::string  &s1,const std::string &s2="hfut"):name(s1),addr(s2){
}

void displayPerson(const Person &p){
    cout<<p.name<<p.addr<<endl;
}

int main(){
    string s="huruohai"; 
    //编译器用给定的string自动创建了一个Person对象，新生成的这个临时对象被传递给displayPerson
    displayPerson(s);//string类型隐式转换成Person类型
    return 0;
}

只允许一步类类型转换

displayPerson("huruohai"); 
//错误：需要把定义的”huruohai“转换成string，
//     再把string转换成Person
//隐式地使用两种转换规则

可以显式的转换：

 string s="huruohai";
 //displayPerson("huruohai"); 错误：需要把定义的”huruohai“转换成string，再把string转换成Person
 displayPerson(string("huruohai"));
 displayPerson(Person("huruohai"));
 displayPerson(s);

抑制构造函数定义的隐式转换

可以通过将构造函数声明为explicit加以阻止隐式转换：

explicit Person(const std::string &s1,const std::string  &s2);

此时，没有任何函数可以隐式地构建Person对象，之前main函数中的用法都无法通过编译：

 string s="huruohai";

 //displayPerson("huruohai"); 错误：需要把定义的”huruohai“转换成string，再把string转换成Person

 displayPerson(string("huruohai"));//错误：构造函数被声明为explicit

 displayPerson(Person("huruohai"));//正确：执行传入两个参数的构造函数

 displayPerson(s); //错误：构造函数被声明为explicit

注！！！！：关键字explicit只对一个实参或者除第一个成员未被初始值列表初始化的构造函数有效。需要多个实参的构造函数不能用于执行隐式转换，所以无须将这些构造函数指定为explicit的。

注：只能再类内声明构造函数时使用explicit关键字，在类外定义时不应重复。

explicit构造函数只能用于直接初始化

发生隐式转换的一种情况是当我们执行拷贝形式的初始化时(使用=)。当我们使用explicit构造函数时只能使用直接初始化，不能执行拷贝初始化。

string s="huruohai";
Person p(s);
Person p=s;//错误：不能执行拷贝初始化。

为转换显式地使用构造函数

displayPerson(static_cast<Person>(s));

7.6 类的静态成员

有时类需要它的一些成员与类本身直接相关，而不是与类的各个对象保持关联。

声明静态成员

在成员的声明前加上关键字static使其与类关联在一起。

类的静态成员存在于任何对象之外，对象中不包含任何与静态数据成员有关的数据。

静态成员函数不与任何对象绑定在一起，它们不包含this指针。作为结果，静态成员函数不能声明成const的，而且也不能在static函数体内使用this指针。

定义静态成员

在类外和类内都可以定义静态成员函数。当在类外定义静态成员时，不能重复static关键字，关键字只能出现类内部的声明语句中。

静态成员在类内声明，类外定义，只能被定义一次。

静态成员的类内初始化

通常情况下，类的静态成员不应该在类的内部初始化。然而，我们可以为静态成员提供const整数类型的类内初始值，不过要求静态成员必须是字面值常量类型的constexpr。

class Account{
public:
   static constexpr int period=30;//period是常量表达式
   double daily_tbl[period];
};

若在类的内部提供了一个初始值，则成员的定义不能再指定一个初始值：

constexpr int Account::period;//初始值在类的定义内提供

注！！！：即使一个常量静态数据成员在类内部被初始化了，通常情况下也应该在类的外部定义一下该成员。