【c++中的public private protected】

public类型的变量和方法可以被当前类的对象或者对象指针访问，而private和protected类型的不可以被对象和类对象指针访问，但是对象中的方法可以访问对象中任意的public，protected，private类型方法和变量。

public继承时，子对象或者子对象指针可以访问父对象中的public变量，而不能访问父对象中的private和protected变量以及方法。

不论何种继承，子对象的方法可以访问父对象的public和protected方法和变量，永远不能访问父对象中的private方法和变量。

private继承时，子对象或者子对象指针不可以访问父对象中所有的public，private和protected变量。

protected继承时，子对象或者子对象指针不可以访问父对象中所有的public，private和protected变量。（同private继承）

也即：

public继承：基类public成员，protected成员，private成员的访问属性在派生类中分别变成：public, protected, private

protected继承：基类public成员，protected成员，private成员的访问属性在派生类中分别变成：protected, protected, private

private继承：基类public成员，protected成员，private成员的访问属性在派生类中分别变成：private, private, private

继承的总结：
1.基类private成员无论以什么方式继承到派生类中都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

2.基类private成员在派生类中不能被访问，如果基类成员不想在派生类外直接被访问，但需要在派生类中访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

3.基类的私有成员在子类都是不可见；基类的其他成员在子类的访问方式就是访问限定符和继承方式中权限更小的那个（权限排序：public>protected>private）。

4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，但最好显式地写出继承方式。

测试代码：

#pragma once

#include <iostream>

using namespace std;

#define PUBLIC_INT_VALUE		1
#define PROTECTED_INT_VALUE		2
#define PRIVATE_INT_VALUE		3

class TestBase {
public:
	TestBase();
	~TestBase();

protected:
	int base_protected;
private:
	int base_private;
public:
	int base_public;

public:
	void basepublic();
private:
	void baseprivate();
protected:
	void baseprotected();
};

TestBase::TestBase() {
	base_public = PUBLIC_INT_VALUE;
	base_protected = PROTECTED_INT_VALUE;
	base_private = PRIVATE_INT_VALUE;

	cout << __FUNCTION__ << endl;
}

TestBase::~TestBase() {
	cout << __FUNCTION__ << endl;
}

void TestBase::basepublic() {
	base_public++;
	cout << __FUNCTION__ << endl;
}

void TestBase::baseprivate() {
	base_private++;
	cout << __FUNCTION__ << endl;
}

void TestBase::baseprotected() {
	base_protected++;
	cout << __FUNCTION__ << endl;
}




class testclass :protected TestBase {
public:
	testclass();
	~testclass();

	void testclassfun();
};


testclass::testclass() {

	cout << __FUNCTION__ << endl;
}

testclass::~testclass() {
	cout << __FUNCTION__ << endl;
}

void testclass::testclassfun() {
	this->base_protected = 0;
	this->base_public = 0;

	this->basepublic();
	this->baseprotected();

	cout << __FUNCTION__ << endl;
}