Primer (十三)

类

class A {
    public:
    A() = default; // 因为有自定义的构造函数，覆盖了默认构造函数，用default可以暴露出默认构造函数
    A(int input):a(input),b(0){} // 构造函数不能是const的
    void func1() const {cout<<a<<endl;} // 定义在类内的，默认为内联函数
    inline void func2() const {cout<<b<<endl;} // 显式定义为内联
    void func2(int input) const; // 对func2的重载，声明在类内，定义在类外
    void func3() const {a++;cout<<a<<endl;} // const常量成员函数可以修改带mutable参数的成员变量
    private:
    mutable int a; // 带mutable，可以被任何成员函数修改
    int b;
};
inline void A::func2(int in) const { // 在类外，显式定义为内联

    cout<<a+b+in<<endl; // 推荐使用声明在类内，定义在类外，类外显示式声明内联的方式，内联函数定义与类在同一个

头文件中
}
class B {
    private:
    std::vector<A> bbb{5,A(10)}; // 推荐使用类内初始值初始化，初始化只能用=或者{}
};
main () {
    A a(10);
    a.func1(); // 10
    a.func2(); // 0
    a.func2(20); // 30
    a.func3(); // 11
    B b;
    return 0;
}
class C {
    public:
    C& func1() {a++;return *this;} // 返回对象的引用
    C func2() {a++;return *this;} // 返回对象的复制
    const C& func1() const {return *this;} // 返回对象的常引用，对于const成员方法，如果返回的是引用，必须是

常引用，因为默认传递进去的this是const C *const this，返回的*this是const C&，这里是func1的重载，函数有没有结尾

const也属于重载，const对象只能调用const函数，非const对象会优先调用非const函数
    int a=10;
};
main() {
    C c;
    c.func1().func2(); // 12 先返回引用，然后返回复制
    cout<<c.a<<endl; 
    c.func2().func1();// 13 先返回复制，用复制加一，对象c只加一了第一次
    cout<<c.a<<endl;
    const C d;
    cout<<d.func1().a<<endl; // d是一个const，会使用重载的const func1，返回的是常引用，此时不能再调用func2

因为常引用不能改变a，除非a是mutable

    return 0;
}
class C {
    public:
    C& const f1() const{f3();return *this;} // f1的const重载

    C& f1() {f3(); return *this;}
    private:
    void f3() const {cout<<a<<end;}; // 更好的方法是，两个重载都调用private的第三个方法，因为f3定义在类内，

是内联的，所以并没有函数多次调用的开销，public里面的重载只控制返回类型是否为const，不做逻辑
    a=10;
}
class A; // 声明A类，为了D类可以声明
class D { // D类提前声明了，但是由于形参中有A类，所以A类又要提前声明
    public:
    void function(A);
};
class A { 
    friend class B; // 声明B类是A类的友元类，可以访问A类的私有成员，友元
类B不用提前声明
    friend void D::function(A); // 声明D类的function可以访问A类的私有
成员，因为用到了D类，所以必须提前声明D类
    int a=10;
};
class B { 
    public:
    void function(){A a;cout<<a.a<<endl;} // 定义中用到了A类，所以A类
要提前声明
};
// 友元关系不能传递，每个类定义自己的友元

int in=5; // 外围全局变量in
class A { 
public:
    void function() {
        cout<<::in<<endl; // ::in表示in使用的是最外层的类外变量
        cout<<in<<endl; // 这里的in先查找类内的声明，然后再查找全局变量
    }   
private:
    int in=10; // 类内声明，在function中覆盖类外的in
};

int main() {
    A a;
    a.function(); // 5 10
    return 0;
}