C++中的类

#include <iostream>
using  namespace std;

class Box 
{
private://不写也可以默认是private
	double width;//只能通过成员函数间接访问和设置width的值，不能通过对象直接访问，这是封装的特点
public :
		double length;
		double getlen(void);//成员函数一般都是写在public中
		void setwidth(int setvalue);
		double getwidth(void);
protected :
	/*protected（受保护）成员变量或函数与私有成员十分相似，
	但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。
	也就是说在父类中protected和private是一样的，只能通过成员函数进行访问*/
	double heigth;

};
double Box::getlen(void)
{
	return length;
}
void  Box::setwidth(int setvalue)
{
	width = setvalue;
}
double Box::getwidth(void)
{
	return width;

}
int main()
{

	Box Mybox;//定义对象
	//Mybox.width=5;  会出现字段width不可访问
	//我们可以这样设置
	Mybox.setwidth(5);
	cout << "宽度被设置为多少" << Mybox.getwidth() << endl;
	Mybox.length = 10;//public成员在外部可以访问正确
	cout << "长度被设置为多少" << Mybox.getlen() << endl;

	return 0;
}

总结

1. public中的成员是可以在外部直接访问的
2. private中的成员不可以直接访问，只能通过成员函数进行间接访问。
3. public在父类中的作用和private一样，但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。下图说明

private的继承在子类不可以直接访问的，只能通过父类函数进行访问 

#include <iostream>
using namespace std;
class animal
{
private:
	char color;
public:
	double length;

protected:
	double leg;
};

class dog :public animal
{
public:
	int paw;//爪子
	char getcolor(void);
};
//下面这样是错误的，原因private不可见
char  dog::getcolor(void)
{
	color = 'R';
	return color;
}

错误	C2248	“animal::color”: 无法访问 private 成员(在“animal”类中声明）

 protected

#include <iostream>
using namespace std;
class animal
{
private:
	char color;
public:
	double length;

protected:
	double leg;
};

class dog :public animal
{
public:
	int paw;//爪子
	char getcolor(void);
};
//下面这样是错误的，原因private不可见
char  dog::getcolor(void)
{
	leg= 4;
	return leg;
}
/* 类似与
class dog :public animal
{
private:
	char color;//存在但是不可见只能通过基类函数对其进行访问
public:
	double length;
	int paw;//爪子
	char getcolor(void);

protected:
	double leg;//存在而且可见，这就是protected与private的最大区别


};
*/

 继承

继承中的特点

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

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

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

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

但无论哪种继承方式，上面两点都没有改变：

• 1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；

• 2.protected 成员可以被派生类访问。

 总结就是继承有三种，通过三种继承可以得到的继承过来的成员会发生改变。

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class 子类: 访问修辞符 父类

例如
class animal
{
private:
	char color;
public:
	double length;
protected:
	double leg;
};
class dog :public animal
{
public:
	int paw;//爪子
};

其中，访问修饰符 是 public、protected 或 private 其中的一个，父类 是之前定义过的某个类的名称。如果未使用访问修饰符 ，则默认为 private。

一个派生类继承了所有的基类方法，但下列情况除外：

• 基类的构造函数、析构函数和拷贝构造函数。
• 基类的重载运算符。
• 基类的友元函数。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

• 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

#include <iostream>
using namespace std;
class animal
{
private:
	char color;
public:
	double length;
protected:
	double leg;
};
//继承
class dog :public animal
{
public:
	int paw;//爪子
};
//这个继承的意是相当于从新定义一个类，然后
/*class dog
{
   private:
	char color;//这个不可以直接访问，这是private和protected的最大区别
public:
	double length;
    int paw;//爪子
protected:
	double leg; 
}*/
int main()
{

	dog smalldog;//创建对象
	smalldog.length=10;



	return 0;


}

 可以总结为下面一个表，不管是public，private，protected继承都遵循下面可见不可见原则，只是不用的继承改变了成员的是public还是，但是成员能不能访问和什么类型的继承没有关系

访问	public	protected	private
同一个类	yes	yes	yes
派生类	yes	yes	no
外部的类	yes	no	no

就是同一个类的话都可以直接或者间接访问

派生类(子类)不管那种方式继承，private都不可以访问，如果想访问只能通过父类的成员函数访问，子类的成员函数是看不到的，也不能访问

外部类就是其他的类

下面这种是可以的

#include <iostream>
using namespace std;
class animal
{
private:
	char color;
public:
	double length;
	char getcolor(char a);
protected:
	double leg;
};

char  animal::getcolor(char a)
{
	color = a;
	return color;
}
class dog :public animal
{
public:
	int paw;//爪子
	
};
//下面这样是错误的，原因private不可见

/* 类似与
class dog :public animal
{
private:
	char color;//存在但是不可见只能通过基类函数对其进行访问
public:
	double length;
	int paw;//爪子
	char getcolor(void);

protected:
	double leg;//存在而且可见，这就是protected与private的最大区别


};
*/
int main()
{

	dog smalldog;
	cout<<"颜色是多少"<<smalldog.getcolor('r') << endl;




	return 0;


}