2022-03-02

字数统计: 2.9k字 | 阅读时长: 10分

C++ primer 7章类

第七章类（Class）

定义抽象数据类型

类背后的基本思想：数据抽象（data abstraction）和封装（encapsulation）。
数据抽象是一种依赖于接口（interface）和实现（implementation）分离的编程技术。

类成员（Member）

必须在类的内部声明，不能在其他地方增加成员。
成员可以是数据，函数，类型别名。

类的成员函数

成员函数的声明必须在类的内部。
成员函数的定义既可以在类的内部也可以在外部。
使用点运算符 . 调用成员函数。
必须对任何const或引用类型成员以及没有默认构造函数的类类型的任何成员使用初始化式。
ConstRef::ConstRef(int ii): i(ii), ci(i), ri(ii) { }
默认实参： Sales_item(const std::string &book): isbn(book), units_sold(0), revenue(0.0) { }
*this：
- 每个成员函数都有一个额外的，隐含的形参this。
- this总是指向当前对象，因此this是一个常量指针。
- 形参表后面的const，改变了隐含的this形参的类型，如 bool same_isbn(const Sales_item &rhs) const，这种函数称为“常量成员函数”（this指向的当前对象是常量）。
- return *this;可以让成员函数连续调用。
- 普通的非const成员函数：this是指向类类型的const指针（可以改变this所指向的值，不能改变this保存的地址）。
- const成员函数：this是指向const类类型的const指针（既不能改变this所指向的值，也不能改变this保存的地址）。

非成员函数

和类相关的非成员函数，定义和声明都应该在类的外部。

练习7.6：定义Sales_data类的add，read和print

#include <string>
#include <iostream>

struct Sales_data {
    std::string const& isbn() const { return bookNo; }; //不需要改变的量前面加上引用比较合适，无需改变值，最好声明为常量引用
    Sales_data& combine(const Sales_data&);

    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

// member functions.
Sales_data& Sales_data::combine(const Sales_data& rhs)
{
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

// nonmember functions
std::istream &read(std::istream &is, Sales_data &item)//read要改变值，所以声明为普通的引用
{
    double price = 0;
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return is;
}

std::ostream &print(std::ostream &os, const Sales_data &item)
{
    os << item.isbn() << " " << item.units_sold << " " << item.revenue;
    return os;
}

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

类的构造函数

类通过一个或者几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做构造函数，构造函数不能声明为const。
构造函数是特殊的成员函数。
构造函数放在类的public部分。
与类同名的成员函数。
Sales_item(): units_sold(0), revenue(0.0) { }
=default要求编译器合成默认的构造函数。(C++11)
初始化列表：冒号和花括号之间的代码： Sales_item(): units_sold(0), revenue(0.0) { }

例子：定义树的结点的结构的构造函数

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}//分别是实例化时传入的参数有几个，默认的参数值，{}代表未定义的函数体
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

访问控制与封装

访问说明符（access specifiers）：
- public：定义在 public后面的成员在整个程序内可以被访问； public成员定义类的接口。
- private：定义在 private后面的成员可以被类的成员函数访问，但不能被使用该类的代码访问； private隐藏了类的实现细节。
使用 class或者 struct：都可以被用于定义一个类。唯一的却别在于访问权限。
- 使用 class：在第一个访问说明符之前的成员是 priavte的。
- 使用 struct：在第一个访问说明符之前的成员是 public的。

友元

允许特定的非成员函数访问一个类的私有成员。
友元的声明以关键字 friend开始。 friend Sales_data add(const Sales_data&, const Sales_data&);表示非成员函数add可以访问类的非公有成员。
通常将友元声明成组地放在类定义的开始或者结尾，注意需要在类内声明友元函数。
类之间的友元：
- 如果一个类指定了友元类，则友元类的成员函数可以访问此类包括非公有成员在内的所有成员。
在类中声明友元之后只是影响访问权限，并非普通意义的声明。

封装的益处

确保用户的代码不会无意间破坏封装对象的状态。
被封装的类的具体实现细节可以随时改变，而无需调整用户级别的代码。

类的其他特性

成员函数作为内联函数inline：
- 在类的内部，常有一些规模较小的函数适合于被声明成内联函数。
- 定义在类内部的函数是自动内联的。
- 在类外部定义的成员函数，也可以在声明时显式地加上 inline。
- 关键字inline必须与函数定义放在一起才能使函数成为内联函数，仅仅将inline放在函数声明前面不起任何作用，再调用函数时，声明为内联的函数在调用点展开。
- 如果函数调用的时间大于函数内部运行的时间，声明为内联比较合适。
返回*this的成员函数：
- 注意返回类型必须是Screen&不能是Screen
- 如果某个类的某个函数为const类型，如果以引用的形式返回*this，那么它的返回类型是常量引用。
- 通过this指针使用成员的做法虽然合法，但是有点多余。讨论显示使用指针访问成员的优缺点。
优点：程序的意图更明确，函数的参数可以与成员同名，如：
1
void setAddr(const std::string &addr) { this->addr = addr; }
```
 缺点：有时候显得有点多余，如:
```

1	std::string getAddr() const { return this->addr; }

可变数据成员（mutable data member）：
- mutable size_t access_ctr;
- 永远不会是const，即使它是const对象的成员。
类类型：
- 每个类定义了唯一的类型，即使两个类的成员函数完全一样。
- 类也可以像函数一样将声明和定义分开。
- 类必须定义后才能才能将数据成员声明为这种类类型，因为只有定义后编译器才知道类需要多少空间；然而类只需声明不需要定义之后就能声明对类的引用或指针。
友元再探：

using关键词的作用之一：为数据类型起别名，相当于typedef

c++中using的用法_YoungYangD的博客-CSDN博客_c++ using

1 2	typedef std::vector<int> intvec; using intvec = std::vector<int>; //这两个写法是等价的

我们定义的类的成员函数中，常常有一些成员函数不改变类的数据成员，也就是说，这些函数是“只读”函数，而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数前都加上const关键字进行标识，显然，可提高程序的可读性。

类的作用域

每个类都会定义它自己的作用域。在类的作用域之外，普通的数据和函数成员只能由引用、对象、指针使用成员访问运算符来访问。
函数的返回类型通常在函数名前面，因此当成员函数定义在类的外部时，返回类型中使用的名字都位于类的作用域之外。
如果成员使用了外层作用域中的某个名字，而该名字代表一种类型(typedef)，则类不能在之后重新定义该名字。

typedef string Type;
Type initVal(); 
class Exercise {
public:
    typedef double Type; //类内重新定义，错误！
    Type setVal(Type);
    Type initVal(); 
private:
    int val;
};
Type Exercise::setVal(Type parm) { 
    val = parm + initVal();     
    return val;
}

类中的类型名定义都要放在一开始,不能先使用在定义。

构造函数再探

构造函数初始值列表：
- 类似python使用赋值的方式有时候不行，比如const或者引用类型的数据，只能初始化，不能赋值。（注意初始化和赋值的区别）
- 最好让构造函数初始值的顺序和成员声明的顺序保持一致。
- 如果一个构造函数为所有参数都提供了默认参数，那么它实际上也定义了默认的构造函数。

委托构造函数（delegating constructor, `C++11`）

委托构造函数将自己的职责委托给了其他构造函数。
Sale_data(): Sale_data("", 0, 0) {}

隐式的类型转换

如果构造函数只接受一个实参，则它实际上定义了转换为此类类型的隐式转换机制。这种构造函数又叫转换构造函数（converting constructor）。
编译器只会自动地执行仅一步类型转换。
抑制构造函数定义的隐式转换：
- 将构造函数声明为explicit加以阻止。
- explicit构造函数只能用于直接初始化，不能用于拷贝形式的初始化。

聚合类（aggregate class）

满足以下所有条件：
- 所有成员都是public的。
- 没有定义任何构造函数。
- 没有类内初始值。
- 没有基类，也没有virtual函数。
可以使用一个花括号括起来的成员初始值列表，初始值的顺序必须和声明的顺序一致。

字面值常量类

constexpr函数的参数和返回值必须是字面值。
字面值类型：除了算术类型、引用和指针外，某些类也是字面值类型。
数据成员都是字面值类型的聚合类是字面值常量类。
如果不是聚合类，则必须满足下面所有条件：
- 数据成员都必须是字面值类型。
- 类必须至少含有一个constexpr构造函数。
- 如果一个数据成员含有类内部初始值，则内置类型成员的初始值必须是一条常量表达式；或者如果成员属于某种类类型，则初始值必须使用成员自己的constexpr构造函数。
- 类必须使用析构函数的默认定义，该成员负责销毁类的对象。

类的静态成员

非static数据成员存在于类类型的每个对象中。
static数据成员独立于该类的任意对象而存在。
每个static数据成员是与类关联的对象，并不与该类的对象相关联。
声明：
- 声明之前加上关键词static。
使用：
- 使用作用域运算符::直接访问静态成员:r = Account::rate();
- 也可以使用对象访问：r = ac.rate();
定义：
- 在类外部定义时不用加static。
初始化：
- 通常不在类的内部初始化，而是在定义时进行初始化，如 double Account::interestRate = initRate();
- 如果一定要在类内部定义，则要求必须是字面值常量类型的constexpr。

C++ primer 7章 类

第七章 类 （Class）