构造函数

问题1:构造函数有什么特点？初始化的顺序又怎么样的？

类外访问类中的成员，只能访问public成员，通过对象访问成员。

特点：

1.构造函数名和类名相同；

2.构造函数没有返回值，void也算返回值；

3.构造函数创建对象的时候调用构造函数；

函数名用对象名替换，剩下的部分必须一致（参数）

4.默认的构造函数没有参数，

注意点：如果自己写了构造函数——默认的构造函数不存在；

5.一般情况下，构造函数负责给基本成员初始化；

6.构造函数和普通函数一样，能重载能缺省；

7.构造函数必须是public属性

构建对象——类外构建——就是调用构造函数

类外访问成员——public

举例：

第四条：默认的构造函数没有参数，所以在创建的时候可以通过 Dog dog; 或 Dog* dog = new Dog;相当于省略了参数()形式。

第四条，第五条：如果构造函数重写后，就需要按照重写的构造函数进行初始化：

Dog dog1(1,2); 或 Dog* dog2 = new Dog(1,2);

#include <iostream>

using namespace std;

class Dog
{
public:
    Dog(int aa,int bb):a(aa),b(bb)  {}

protected:
    int a;
    int b;

private:
};

int main()
{
    Dog dog1(1,2);
    Dog* dog2 = new Dog(1,2);

    return 0;
}

当然这里隐含了一个问题就是c++中创建对象的三种方式：

这里大家可以去参考网上的博客很多，我把我看的比较细的一篇分享给大家：https://www.cnblogs.com/lizhenlin/p/6813455.html。摘录其中比较干货的几点：

虚拟内存区域的区别：

A a(1);  //栈中分配，隐式调用 

A b = A(1);  //栈中分配，b被称为句柄，显示调用 

A* c = new A(1);  //堆中分配

调用方法的不同：

对象是通过： "句柄.函数" 访问，new的对象是通过指针形式进行访问的： "句柄->函数"。

 

承接上文：

构造函数的普通构建：

#include <iostream>

using namespace std;

class Dog
{
public:
    Dog(int aa,int bb):a(aa),b(bb)  {}
    print()
    {
        cout<<a<<endl;
        cout<<b<<endl;
    }

protected:
    int a;
    int b;
private:

};

int main()
{
    Dog dog1(1,2);
    Dog* dog2 = new Dog(1,2);

    dog2->print();
    dog1.print();

    return 0;
}

运行结果：

第六点：构造函数只是特别意义的函数，它具有函数重载和参数缺省的特性

#include <iostream>

using namespace std;

class Dog
{
public:
    Dog(int aa,int bb):a(aa),b(bb)  {}
    Dog()   {}
    print()
    {
        cout<<a<<endl;
        cout<<b<<endl;
    }

protected:
    int a;
    int b;
private:

};

int main()
{
    Dog dog1(1,2);
    Dog* dog2 = new Dog(1,2);

    Dog dog11();
    Dog* dog21 = new Dog;

    return 0;
}

c++构造函数初始化顺序

这个就直接参加网上的一篇博客就好：https://blog.csdn.net/qq_30835655/article/details/66971183。

构造函数初始化按照如下顺序进行

1. 首先构造虚拟基类，任何虚拟基类的构造函数按照它们被继承的顺序构造；

2. 其次构造非虚拟基类，任何非虚拟基类的构造函数按照它们被继承的顺序构造；

3. 接着构造成员对象，任何成员对象的构造函数按照它们声明的顺序调用；

4. 最后调用类自身的构造函数；

析构函数就无脑的将构造函数顺序反转即可。不过是在 return 0; 之前才释放对象的，所以应该在所有语句都执行完要释放之前才调用析构函数。

举一个栗子：

#include <iostream>

using namespace std;

class OBJ1
{
public:
	OBJ1() { cout << "OBJ1" << endl; }
	~OBJ1() {	cout << "OBJ1 destory" << endl;}
};

class OBJ2
{
public:
	OBJ2() { cout << "OBJ2\n"; }
	~OBJ2(){cout << "OBJ2 destory" <<endl;}
};

class Base1
{
public:
	Base1() { cout << "Base1" << endl; }
	~Base1() { cout << "Base1 destory" << endl; }
};

class Base2
{
public:
	Base2() { cout << "Base2" << endl; }
	~Base2() { cout << "Base2 destory" << endl; }
};

class Base3
{
public:
	Base3() { cout << "Base3" << endl; }
	~Base3() { cout << "Base3 destory" << endl; }
};

class Base4
{
public:
	Base4() { cout << "Base4" << endl; }
	~Base4() { cout << "Base4 destory" << endl; }
};

class Derived :public Base1, virtual public Base2,
	public Base3, virtual public Base4
{
public:
	Derived() { cout << "Derived ok" << endl; }
	~Derived() { cout << "Derived destory" << endl; }
protected:
	OBJ1 obj1;
	OBJ2 obj2;
};

int main()
{
	Derived aa;
	cout << "construct ok"<<endl;
	return 0;
}

运行结果：