16章 类: 不可变性 & 具体类型

16.1 类基础

1 访问类的(而非对象)成员 (static 成员 / 成员函数): 类名 + 作用域操作符 ::

    struct S
    {
        int f();
        static in sm;
    };
    int X::sm {7};
    int (S::*) pmf() {&S::f};

2 不可变性: 物理常量性 / 逻辑常量性

    成员 data 变化, 就视为变化 / interested data 变化时, 才视为变化
    
    [1] mutable (直接) 成员 改变, 不算变化
    
    [2] 指针成员 所指 notInterested data 改变, 不算变化 
    
    const 成员函数 中 支持这2种case 
    
    [1] mutable - 直接缓存编程
    
    [2] `间接访问` / `间接缓存` 编程 --- 推广: 延迟求值
    
    应用: 某字符串 构造很耗时 -> 保存其 copy 放 cache -> 原始 string 发生改变 时才 copy on write   
                                                
    // === [1]
    class A
    {
    public:
        string string_rep() const;      
    private:
        mutable bool    cache_valid;         // interested data (字符串) `是/否 已改变`     
        mutable string  cache;              
        void    compute_cache_value() const; // 填入 缓存
    };

    string A::string_rep() const
    {
        if(!cache_valid)            // false: interested data 已改变 
        {
            compute_cache_value();
            cache_valid = true;
        }
        return cache;
    }
    
    // === [2]
    struct cache
    {
        bool valid;
        string rep;
    };
    
    class Date
    {
    public:
        string string_rep() const;      
    private:
        cache* c; // 指针成员
        void compute_cache_value() const; 
    };
        
    string Date::string_rep() const
    {
        if(!c->valid) 
        {
            compute_cache_value();
            c->valid = true; // not interested data
        }
        return c->rep;
    }               

3 自引用: return *this

this 的 类型: X* / const X*            
        
    类 X 的 non-const / const 成员函数 中

4 成员类型/嵌套类

特殊权限: 引用其所属类的 private类型和static 成员而不必通过其所属类 的对象`

5 成员函数

    (1) `需 直接访问 类的表示` 的函数才应该作成员函数
    
    (2) non-static 成员函数: “知道"  是 `哪个对象 调用 它`, compiler 隐含传入 `其 调用对象 的 指针 this`
    
    (3) 可通过 `本 class 另一对象` 直接访问其`private 成员`: 同1个类的2个对象互为 友元 
            
        void A::f(const A& rhs)
        {
            cout << rhs.x; // rhs 的 private 成员 x
        }
        
6 类定义 本质是 `类声明`: 不同源文件 中 用 #include 重复类定义不会违反 ODR
    
7 Ctor 创建 `类的不变式` 

    `other 成员函数` 不用担心会遇到 `未初始化的 数据`
    
8 explicit ctor

    默认下, 从 paraType 到 ClassType 转换 会 implicitly 发生
        
    explicit 限制只能在 `初始化 & 显式类型转换` 

9 static 成员

    是 `类 的一部分`, 但 不是类的 `某个对象 的 一部分`
    多线程 数据竞争
    
10 `绕过 private 保护` 是 欺骗手段: `地址操作 和 显式类型转换` 

16.2 具体类

1 含义: 类的表示 是其 定义的一部分

2 优势 

1) 无须通过 指针/引用 间接访问 其 对象 => 无 间接访问 时空开销

2) 编译时已知 

    [1] `类型大小`: 可在 `栈中分配` 对象可分配于 栈 / 静态分配的内存 / 其他对象

    [2] 对象 `内存布局`: inline 容易

3 应用: 性能攸关 的 小类型: 复数 / 智能指针 / vector_base

1)作 成员, 实现 新类型

2)极少派生: 无 虚函数 和 RTTI

4 又称 `值类型`: 面向值的程序设计
        
5  非成员 helper 函数: `不需要 直接访问` 类的表示 

    1) 其声明 与 类声明 放  `同一 头文件` 
    2) 与 类 放 `同一 namespace`