Primer (十四)

类

class A { 

    public:

    A() {a=10;b=a;} // 错误，没有进行初始化，只进行了赋值，由于const和引用都需要初始化，所以错误

    A():b(a),a(10){} // 正确，初始化顺序是成员函数声明顺序，先b后a

    A():a(10),b(a){} // 有时错误，有的编译器不认可不按声明顺序的初始化

    void f(){cout<<a<<" "<<b<<endl;}

    private:

    constint &b; 

    constint a;

};

class B { 

    public:

    B(int i1,int i2):a(i1),b(i2){} // 正常构造函数

    B(int i3):B(i3,10){a=i3+1;} // 构造函数委托了上一个构造函数

    B():B(50){b=15;} // 默认构造函数委托了上一个构造函数，执行顺序如下：a=50,b=10; a=51,b=10;

a=51,b=15;

    void f(){cout<<a<<" "<<b<<endl;}

    private:

    int a;

    int b;

};

class C { 

    public:

    C(int i){a=i;} // 这里定义了构造函数，覆盖了默认构造函数

    private:

    int a;

};

class D { 

    public:

    D(){}

    C c; // 编译错误，因为c没有默认构造函数，无法初始化 D d也是错误的，最好都提供默认构造函数

};

class A {

    public:

        explicit A(int i):a(i){} // 构造函数，前面加explicit表示禁止通过此构造函数执行隐式类型转换，只有单形参的构造函数可以类型转换，explicit只会加在这类函数前

        A(std::string s):a(2){} // 没有加explicit，所以可以类型转换

        void f(){cout<<a<<endl;}

    private:

        int a;

};

class B {

    public:

        void f(A a){a.f();} // f中可以传入A类型对象，也可以传入一个字符串，进行默认类型转换

};

class C {

    public:

        int a; // 聚合类：所有都是public 没有构造函数 没有类内初始化

        std::string b;

        void f(){cout<<a<<" "<<b<<endl;}

};

int main() {

    B b;

    b.f(1); // 错误，f(int)是explicit的，不能将1转化成A

    b.f(A(1)); // 正确，显示定义了A temp(1); f(temp);无视explicit，explicit只限制默认转换

    b.f(static_cast<A>(1)); // 正确，强制类型转换无视explicit

    std::string s="abc"; // 正确，b.f(s)由string默认转换成A

    b.f(s);

    b.f("abc"); // 错误，默认转换只允许一步，这里是两步string temp="abc";f(temp);多了一步从const char*转化成string。另外，string类的string(const char*)构造函数不是explicit的，所以使用string的地方，都可以用"abc"常量代替;而vector类的vector(int);是expicit的，不允许使用int代替vector;

    C c = {1,"abc"}; // 聚合类的初始化

    C c2 = {"abc",1}; // 必须按照形参声明顺序

    c.f();

    return0;

}

class A {

    public:

        void h(){a++;cout<<a<<endl;} // 定义类的非静态方法，静态成员是和类一起诞生的，在对象出现之前，所以非静态方法可以调用静态成员

        static void j(); // 声明类的静态方法

    private:

        static int a; // 声明类的静态成员

        int b; // 声明类的非静态成员

};

int A::a = 10; // 类的静态成员必须在类外进行初始化，初始化时不加static，static只出现在类内

void A::j() { // 静态方法也是不加static

    a++;

    b++; // 错误，静态方法中不可以调用非静态成员，因为此时对象没有初始化，非静态成员没有定义

    cout<<a<<endl;

}

int main() {

    A::j(); // 11 静态成员调用不必初始化对象，使用类调用或者对象调用

    A a;

    a.h(); // 12 对象可以调用静态和非静态成员

    a.j(); // 13

    return 0;

}