C++中与类有关的注意事项（更新中~~~）

• 关于构造函数的调用次序，见下列代码

#include<iostream>
using namespace std;
class A
{
    private:
        int x;
    public:
        A():x(0){ cout << "Construct A----" << x << endl; }
        A(int i):x(i){ cout << "Construct A----" << x << endl; }
        ~A() { cout << "Des A----" << x << endl; }
};
class B
{
    private:
        int y;
    public:
        B():y(0){ cout << "Construct B----" << y << endl; }
        B(int i):y(i){ cout << "Construct B----" << y << endl; }
        ~B() { cout << "Des B----" << y << endl; }
};
class C
{
    private:
        int z;
    public:
        C(int i):z(i){ cout << "Construct C----" << z << endl; }
        ~C() { cout << "Des C----" << z << endl; }
};
class D:public B
{
    public:
        A a0, a4;       // l1
        B b2, b1;       // l2
        C c1, c2;       // l3                //其构造函数调用次序与这里的顺序有关
        D():c2(2), c1(1), a4(4),B(1), b2(3) { cout << "Construct D----5" << endl; }         //B(i)调用的是D的基类构造函数，它首先开始
        ~D(){ cout << "Des D----5" << endl; }

};
int main()
{
    D d;
}

当然了，首先调用基类的构造函数是不容置疑的，不管它在哪里，记住即可，不过关于对象成员的构造函数的调用还需注意， 见 L1, L2, L3, 它们的构造函数的调用次序与它们在此的相对次序有关，如类A排在第一行，因此先调用关于它的对象，这里还应再注意一点，尽管先定义了它的对象成员，不过它不会立即调用其默认构造函数，而是去看看你有没有写相应的初始化(注意：这里是指在类里面，而不是指main函数内以及类外函数，对于类外函数应注意，在定义类的同时必须给它附上一定的值，不过这根据需要而定，如果你已经设置了无参构造函数了或者你在类内定义了一些set函数)，比如调用完基类构造函数后优先调用a0的构造函数，但初始化列表中并没有它，故调用它的默认构造函数，然后调用a4的构造函数，依此类推，就不难理解编译运行后的结果了。

关于析构函数的调用只需知道它与构造函数的调用刚好对称即可。

针对继承，其构造函数的一般调用顺序为基类构造函数 ---> 成员对象的构造函数 ---> 它自身的构造函数（这里是指初始化列表后大括号内的内容）

 

•  类的静态成员（static member）必须在类内声明，在类外初始化。
• 类里面的任何成员变量在定义时是不能初始化的，尽管你可以编译过。
• 类的一个对象调用了一次构造函数之后，是不允许再次调用构造函数的。
• 如果一个类是另一个类的友元类，那么该类的友元函数将不能访问另一个类的私有成员。

class Base
{
    public:
        int x = 0;
    protected:
        double y = 0;
    private:
        float z = 0;
        friend class Deri;
};
class Deri:public Base
{
    protected:
        int dx = 1;
    public:
        friend void f2(Base b);
        void f3(Base b){cout << b.x << " " << b.y << " " << b.z << endl; }  //在友元类内部可以访问另一个类私有成员
};
void f2(Base b)
{
    cout << "======" << endl;
    cout << b.x << " " << b.y << " " << b.z<< endl; //error, y和z都无法访问
    
}

• 类内的函数名不可和数据成员的名称重复。

如

class First1
{
    private:
        int memi; 
        double memd; 
    public:
        int memi(){return memi;} //error
        double getmemd(){return memd;}

};

• 无论是在类外还是在类内访问私有成员时最好设置一个接口，养成一个习惯。

 

#include<iostream>
using namespace std;
class First1
{
    private:
        double memd; 
    public:
        double getmemd(){return memd;}

};
int main()
{
    First1 a;
    cout << a.getmemd() << endl;
}

• 当该类的对象离开了它的域或者delete表达式应用到一个该类的对象的指针上时，析构函数会自动被调用。
• 看一段代码：

#include<iostream>
using namespace std;
class Data
{
    private:
        int d;
    public:
        Data():d(0){}
        Data(const int dd):d(dd){}
        Data operator+(Data b)
        {
            Data c = d + b.d;
            return c;
            /*
                int c = d + b.d;
                return Data(c);         //true,和下面一样
                Data c_(c);
                return c_;      //true
            
            
            */
        }
        friend ostream &operator<<(ostream& os, const Data &b);


};
ostream& operator<<(ostream& os, const Data &b)
{
    os << b.d;
    return os;
}

int main()
{
    Data a, b(1);
    cout << a + b << endl;
    return 0;
}

•  在使用类模板对象时，必须显示地指定模板实参，否则就会报错。
• 在写类模板时，如何需要用到另一个类模板的私有成员，注意千万不要写成普通的友元形式，那样报错报到你哭，步骤自身感觉比较繁琐，见链接https://blog.csdn.net/lezardfu/article/details/61433246,实在不行在另一个类中写相应的public接口。

关于运算符重载需要注意以下几点：

• 作为类成员的重载函数（以类名作为返回类型），其形参看起来比操作数少一个，因为隐式传递，限定为第一个操作数，举个例子，如下：

T operator + (const Data<T> d) {
        return value + d.value;
    }                /*这是一个类模板内的一个成员函数，注意人家
                        在使用类对象时显示的指定模板实参了，不要忘了，另外系统隐藏了一个
                        类对象，一般两个对象中隐藏第一个*/

• 重载>> 和 << 时一般在public处声明（声明时不要忘记它是友元函数），在类外定义，注意它是非成员函数（这其中包括普通函数，友元函数）。但也有例外，比如你写了个类模板，并且你给它写了个运算符重载<<，这时你就不能按照常规做了，要既在类内声明，又在类内定义，同时不要忘记显示指定模板实参。注意：重载<<时写成 “friend ostream& operator<<(ostream &os, const Data<T> &s)”形式，避免出现发现不出来的错。
• 一般将算术操作符定义为非成员函数，如+， - ， *， /，不过也可以将它定义成成员函数

friend Complex operator+(Complex a, double b) {return Complex(a.r + b, a.i);   /*这里定义成友元函数比较好*/

/*注意：写成这样就不对了*/
//例如
Complex(Complex a, Complex b){}     /*如果你想得到a和b相加后的结果，这样写是不对的，因为多了一个*/
/*应写成这样*/
Complex(Complex b)
{
    Complex c;
    ... 
    return c(...);
}

• 一元运算符（如++，--）因为其位置不同而导致重载形式不同，如

friend X& operator++(X& o);         /*相当于++a,自增完后直接返回引用*/
/*或者这样*/ X& operator++();        /*相当于++a,自增完后直接返回引用*/
friend X operator++(X& o, int );    /*相当于a++，自增完后返回一个临时的*/

• 赋值必须返回对*this的引用（如+=, =）
• 下标运算符 [ ] 一般作为类成员函数，中间加上const就更好了。
• 重载类型转化操作符时应注意1.必须定义为类成员函数. 2.不能指定返回类型。 3.必须返回要转换成的类型

class Circle
{
    private:
        double x, y, r;
    public:
        Circle(double a, double b, double c):x(a), y(b), r(c){}
        operator int(){return int(r);}

};

•