c++ 面向对象基础知识

面向对象

访问控制与封装

定义在public说明符之后的成员可在整个程序内被访问。
定义在private之后的成员可以被类的成员函数访问。

struct 或 class 关键字，定义的类的所有成员都是public的时候，那么使用struct。反之，如果希望成员是private的，使用class。

友元

类想把一个函数作为它的友元，只需要增加一个friend关键字开始的函数声明语句即可。

友元声明只能出现在类定义的内部，但是在类内出现的具体位置不限，友元不是类的成员，不受它所在区域访问控制级别的约束。

封装的益处:

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

友元的声明

友元的声明仅仅指定了访问的权限。而非一个通常意义上的函数声明，如果我们希望类的用户能够调用某个友元函数，那么我们就必须在友员声明之外再专门对函数进行一次声明。

类之间的友元关系

如果一个类指定了友元类，则友元类的成员函数可以访问此类包括非公有成员在内的所有成员。

函数重载和友元

如果一个类想把一组重载函数声明成它的友元，它需要对这组函数中的每个分别声明。

令成员作为内联函数

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;
}

inline &Screen::move(pos r, pos c)      // 可以在函数的定义处指定inline
{
    pos row = r * width;
    cursor = row + c;
    return *this;                       //以左值形式返回对象
}

char Screen::get(pos r, pos c) const    // 在类的内部声明成inline
{
    pos row = r * width;
    return contents[row + c];
}

隐式的类类型转换

另一个是从istream到Sales_data的转换:

// 使用istream构造函数创建一个函数传递给combine

item.combine(cin) 这段代码隐式的把cin 转换成 Sales_data, 这个转换执行了一个istream 的 Sales_data 构造函数，该构造函数通过读取标准输入创建了一个临时的Sales_data对象，随后将得到的对象传递给combine。

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

在要求隐式转换的程序上下文中，我们可以通过将构造函数声明为explicit加以阻止:

class Sales_data {
    public:
        Sales_data() = default;
        Sales_data(const std::string &s, unsigned n, double p):bookNo(s), units_sold(n),revenue(p*n) {}
        explicit Sales_data(const std::string &s):bookNo(s){}
        explicit Sales_data(std::istream&);
}

此时没有任何构造函数能用于隐式转换的创建Sales_data 对象，之前的用法item.combine(cin) 无法通过编译；

关键字explicit 只对一个实参的构造函数有效。需要多个实参的构造函数不能用于执行隐式转换，所以无须将这些构造函数指定为explicit的。只能在类内声明构造函数时使用explicit关键字，在外部定义时不能重复。

explicit 构造函数只能用于直接初始化而不能使用explicit 构造函数来执行拷贝形式的初始化。

尽管编译器不会将explicit 的构造函数用于隐式转换过程，但是我们可以使用这样的构造函数显示的强制进行转化

item.combine(static_cast(cin));
// 正确，static_cast 可以使用 explicit 的构造函数。

聚合类

要求类所有成员都是public
没有定义任何构造函数
没有类内初始值

没有基类，没有virtual函数

struct Data {
    int ival;
    string s;
}
Data val1 = {0, "Anna"};

字面值常量类

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

类的静态成员

声明静态成员

静态成员可以是public的或者是 private 的，静态数据成员的类型可以使常量，引用，指针，类类型等。
类的静态成员存在于任何对象之外，对象中不包含任何与静态数据成员有关的数据。
静态成员函数也不与任何对象绑定在一起，它们不包含this指针。作为结果，静态成员函数不能声明为const的，而且我们也不能再static 函数体内使用this指针。
在类的外部定义静态成员时，不能重复static关键字，该关键字只能出现在类内部的声明语句中。
因为静态数据成员不属于类的任何一个对象，所以它们不是在创建类的对象时被定义的。这意味着它们不是由类的构造函数初始化的。而且一般来说我们不能再类的内部初始化静态成员，相反的，必须在类的外部定义和初始化每个静态成员。
静态数据成员和全局变量类似，一旦被定义，就存在于程序的整个生命周期
静态数据成员可以作为默认实参，非静态数据成员不能。

静态成员的类内初始化

静态成员可以通过const整数类型的类内初始值进行初始化。要求静态成员必须是字面值常量类型的constexpr。初始值必须是常量表达式。

class Account {
    private:
        static constexpr int period = 30;
}

拷贝控制

class Foo {
    public: 
        Foo();
        Foo(const Foo&); // 拷贝构造函数
}

[1] C++ primer 中文版第五版笔记