明明白白c++之类的基本操作（c++ primer 的读书笔记 ，类对象， 类用户， 类成员的含义）

一前言

看c++ primer有一个地方看的云里雾里的，这么一段话

可以认为 protected 访问标号是 private 和 public 的混合：
• 像 private 成员一样，protected 成员不能被类的用户访问。
• 像 public 成员一样，protected 成员可被该类的派生类访问。
此外，protected 还有另一重要性质：
• 派生类只能通过派生类对象访问其基类的 protected 成员，派生类对其基类类型对象的 protected 成员没有特殊访问权限

这里就完全看不明白了，可能是翻译的问题导致的，老外写的本来就有点绕，翻译过来就更加绕，很难理解。

那么我们以下面的代码为例子。大家先看看觉得那句话编译会报错。

我之前写的代码都是编译错了之后，自己再去修改，而没有特别仔细的去思考到底为什么定义为pubulic ,protected和private，总是到这里弄不清楚，稀里糊涂就过去了，为了弄清楚，敲了下面的代码，编译之后便一目了然了。

二分析代码

先自己分析一下，然后后面在公布答案。

class A 
{
public:
		int set(A& a);
		int public_a_var;
protected:
		int protected_a_var;
private:
		int private_a_var;
};


int A::set(A &a)
{
		protected_a_var = a.protected_a_var;
		private_a_var = a.private_a_var;
		public_a_var = a.public_a_var;
}
class B:A
{
		public:
				int anotherset(A& a, B& b);
				int public_b_var;
		protected:
				int protected_b_var;
private:
				int private_b_var;
};


int B::anotherset(A& a, B& b)
{
		public_b_var = a.public_a_var ;
		public_b_var = b.public_b_var;
		protected_b_var = a.protected_a_var;
		protected_b_var = b.protected_b_var;
		private_b_var = a.private_a_var;
		private_b_var = b.private_b_var;




		public_a_var = a.public_a_var ;
		public_a_var = b.public_b_var;
		protected_a_var = a.protected_a_var;
		protected_a_var = b.protected_b_var;
		private_a_var = a.private_a_var;
		private_a_var = b.private_b_var;
}


int main()
{
		A main_a;
		int a = main_a.private_a_var;
		int b = main_a.protected_a_var;
		int c = main_a.public_a_var;
}

三含义介绍

1 类成员的含义

首先说一下概念，c++ primer里面类成员，类对象，类用户，这些词语在c++ primer里面用的乱七八糟的，让人看着很费解，如果你本身又是学过别的c++的书籍，看到上面的一段话估计要崩溃的，讲的是嘛啊？

2 类对象的含义

先解释一下上面这句话：

这里类成员这个词没有任何歧义，就是指类里面的所有变量和函数。

类对象这个词存在歧义，而且这本书里面前后都不一样，要看语境了。

第一种是广义的

比如上文中的，main函数里面的main_a ，set函数里面的a,anotherset函数里面的a, b 都是类对象，而且这本书里面的大部分地方类对象就是广义的。

第二种是狭义的，专指类的成员函数里面的作为参数的类对象。

在某些语境里面，个人觉得一般是出现了类的用户这个词之后，类对象就变成狭义了。

上面那句话里面“派生类只能通过派生类对象访问其基类的 protected 成员”，

其实这里可以这么理解吧，派生类的进行什么操作，描述的就是类的函数了，前面加入了条件限制了，那么这个类对象自然就也被限定了起来。

不过读起来就很费劲了。

3 类的用户

这个词语在一般的c++书上貌似是看不到的，突然之间冒出来一个类的用户，就突然感觉复杂了很多。

其实如果第一句话修改为：

像 private 成员一样，protected 成员不能被类的对象访问。

这个时候，你在看第三句话，就会有疑问，既然protect成员不能被类的对象访问，那怎么又“派生类只能通过派生类对象访问其基类的 protected 成员”，这不是前后矛盾么？

其实并不矛盾，作者也是怕用户看到这里看糊涂了，就引入了类的用户。

类的用户，可以专门指外部函数里面的类的对象，例如main函数里面的main_a ,其他几个就不是类的用户了。

四进一步分析

我们分析一下上面的这一段话，其实有一个前提，没说说明白。

因为作者认为大部分人都应该知道，所以就没有说，也没有强调，但是很多人都是半生不熟的c++然后来看这本书，知道它是经典，但是不知道它不是prime，至少你得写了一年的c++代码，至少你得吃过苦头才能明白。

废话不说了，前提是：

类的成员函数中的类对象，可以访问自己的所有类型的成员。

换句话说，狭义的类对象，可以访问自己的所有类型的成员。

类的成员函数中其实是个定语，虽然很长。

第三句话的前半段，“派生类只能通过派生类对象访问其基类的 protected 成员”，因为派生类已经继承了基类，所以protected也是它自己的成员，基于这个前提，它狭义的类对象，自然可以访问自己的protected变量。

第三局话的后半段，当基类对象作为参数的时候，这句话更绕，我们用继承类代替前面那句话的类，就是由于基类对象不属于继承类的成员函数的继承类对象，所以它本质上不属于这个继承类的对象，所以它的权限就和类的用户是一样的。

五分析代码

上面已经把人说晕了，我分析下代码吧。

int A::set(A &a)
{
		protected_a_var = a.protected_a_var;
		private_a_var = a.private_a_var;
		public_a_var = a.public_a_var;
}

这三句话都正确。

这里有两个概念，protected_a_var ，private_a_var已经public_a_var实质是this.开头的，指的是类的成员（其实也是类当前对象的成员），入参是类型A的对象a,由于类型一样，所以可以操作a的任何变量。

这个原理我不知道，面向对象的思想吧，其实面向对象就是仿照人类社会。我们可以这么理解如果大家是一类，或者看成一家人，在构建这个家庭的时候，我们内部的各种东西都是共享的。

但是当我们出了这个家门，在外面的时候，只有我们家公共的信息可以告诉别人，但是私有的密码，必然家里多少钱，银行密码之类的就不能说了。

int B::anotherset(A& a, B& b)
{
		public_b_var = a.public_a_var ;
		public_b_var = b.public_b_var;
		protected_b_var = a.protected_a_var;
		protected_b_var = b.protected_b_var;
		private_b_var = a.private_a_var;
		private_b_var = b.private_b_var;




		public_a_var = a.public_a_var ;
		public_a_var = b.public_b_var;
		protected_a_var = a.protected_a_var;
		protected_a_var = b.protected_b_var;
		private_a_var = a.private_a_var;
		private_a_var = b.private_b_var;
}

看看这段代码，继承其实就像分家了，我们有一些共有的东西，也有一些私有的东西，但是也不是特别的贴切这个比喻。这样吧，就像娶老婆了。老婆说，你的都是我的，我的还是我的。其实都不贴切，如果大家看过龙珠的话，可以这么认为，就像是那美克星人的生殖，儿子继承类父亲的所有能力，而且自己还会不断进步。

废话不说了，我们还是分析加上必要的记忆吧。

先看前六句：

我们根据上面的理解，赋值语句前面的变量，class B都可以访问，后面的如果类型是class B的因为是一家人都可以访问，a 的只能访问public类型的，所以结果为

                public_b_var = a.public_a_var ;
		public_b_var = b.public_b_var;
		protected_b_var = a.protected_a_var;//错误，a.protected_a_var是保护的。
		protected_b_var = b.protected_b_var;
		private_b_var = a.private_a_var;//错误，a.private_a_var是私有的
		private_b_var = b.private_b_var;

下面六句话，继承的时候，继承类的成员只能访问protect和pirvate所以结果如下

                public_a_var = a.public_a_var ;
		public_a_var = b.public_b_var;
		protected_a_var = a.protected_a_var;//错误，a.protected_a_var是保护的。
		protected_a_var = b.protected_b_var;
		private_a_var = a.private_a_var;// 两个错误，private_a_var 和a.private_a_var都不能访问，是私有的
		private_a_var = b.private_b_var;//private_a_var是私有的，赋值语句前面的那个

最后分析main函数里面的

                int a = main_a.private_a_var;//错误，a.private的私有
                int b = main_a.protect_a_var;//错误，a.protect是保护
                int c = main_a.public_a_var;

6 结果。

大家可以编译测试一下：上面文章有原因，本来想标记为红色，但是代码类型的不会标记，如果有达人知道，希望在评论里面回复一下，便于大家查看代码。

class A 
{
public:
		int set(A& a);
		int public_a_var;
protected:
		int protected_a_var;
private:
		int private_a_var;
};


int A::set(A &a)
{
		protected_a_var = a.protected_a_var;
		private_a_var = a.private_a_var;
		public_a_var = a.public_a_var;
}
class B:A
{
		public:
				int anotherset(A& a, B& b);
				int public_b_var;
		protected:
				int protected_b_var;
private:
				int private_b_var;
};


int B::anotherset(A& a, B& b)
{
		public_b_var = a.public_a_var ;
		public_b_var = b.public_b_var;
		protected_b_var = a.protected_a_var;//error
		protected_b_var = b.protected_b_var;
		private_b_var = a.private_a_var;//error
		private_b_var = b.private_b_var;




		public_a_var = a.public_a_var ;
		public_a_var = b.public_b_var;
		protected_a_var = a.protected_a_var;//error
		protected_a_var = b.protected_b_var;
		private_a_var = a.private_a_var;//error
		private_a_var = b.private_b_var;//error
}


int main()
{
		A main_a;
                int a = main_a.private_a_var;//error
		int b = main_a.protected_a_var;//error
		int c = main_a.public_a_var;
}