C++面向对象的程序设计10——子类的构造函数和析构函数

1、子类对父类成员的访问权限

无论通过什么方式（public、protected、private）继承，

在子类内部均可访问父类中的public、protected成员，

private成员不可访问（如果想要子类能够访问，就定义为protected）

  

继承方式只影响外界通过子类对父类成员的访问权限。

    public继承，父类成员的访问权限全部保留至子类；

    protected继承，父类public成员的访问权限在子类中降至protected；

    private继承，父类public、protected成员的访问权限在子类中均降至private。

2. 子类的构造函数

当创建子类对象时, 构造函数的调用顺序：

静态数据成员的构造函数 ->  父类的构造函数 ->  非静态的数据成员的构造函数 -> 自己的构造函数

注意: 

无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用1次!!!

[x]：表示调用的顺序

3、子类的析构函数

子类的析构函数的调用顺序，和子类的构造函数的调用顺序相反！！！

记住，相反即可

示例代码：

// N.h 
#pragma once
class N
{
public:
	N(int);
	~N();
private:
	int number;
};



// N.cpp
#include "N.h"
#include <iostream>


N::N(int number)
{
	this->number = number;
	std::cout << __FUNCTION__ << std::endl;
}


N::~N(void)
{
	std::cout << __FUNCTION__ << std::endl;
}

// M.h
#pragma once
class M
{
public:
	M();
	~M();
};


// M.cpp
#include "M.h"
#include <iostream>


M::M()
{
	std::cout << __FUNCTION__ << std::endl;
}


M::~M(void)
{
	std::cout << __FUNCTION__ << std::endl;
}

// A.h
#pragma once
#include <string>
using namespace std;

class A
{
public:
	A(string);
	~A(void);
private:
	string name;
};


// A.cpp
#include "A.h"
#include <iostream>


A::A(string name)
{
	this->name = name;
	std::cout << __FUNCTION__ << std::endl;
}


A::~A()
{
	std::cout << __FUNCTION__ << std::endl;
}

// B.h
#pragma once
#include "A.h"
#include "M.h"
#include "N.h"

class B: public A
{
public:
	B(int, string);
	~B(void);
private:
	N n1;
	static M Ms;
};


// B.cpp
#include "B.h"
#include <iostream>

M B::Ms;

B::B(int number, string name):n1(number), A(name)
{
	std::cout << __FUNCTION__ << std::endl;
}


B::~B(void)
{
	std::cout << __FUNCTION__ << std::endl;
}

main.cpp

#include "B.h"
#include <iostream>

int main()
{
	{
		B b1(1, "张三");
	}
	cout << " --------------- " << endl;
	B b2(2, "李四");
	system("pause");
	return 0;
}

运行结果：