private、public、protected和friend深入理解,不说话,直接上代码//派生类(derived)分为单继承(inherit)和多继承。基类是对派生类的抽象,派生类是对基类的具体化,是基类的延续。派生类也可以看做是基类的组合(多继承)
//公有派生类的对象可以作为基类的对象处理。格式:class <派生类名称>:<继承方式><基类名>。继承方式:(virtual) private,public,protected.
/*
//继承的访问权限:
基类中的私有成员在派生类中是隐藏的,只能在基类内部访问,一般通过public函数访问
派生类中成员不能访问基类的private成员,但可以访问基类中的public和protected成员。
派生类从基类public继承时,基类的成员类型都不变,public\private\protected仍然是public\private\protected。
派生类从基类private继承时,基类的pbulic和protected成员都变成private成员。而基类的private成员不能被访问。
派生类从基类protected继承时,基类的public成员在派生类中变为protected成员,protected成员仍为protected成员。
*/
// //类和结构体的区别:类的成员默认为private,而结构体的成员默认为public
//关于继承:class的继承默认是private继承方式,而结构体是public继承方式
#include<iostream>
using namespace std;
class base
{
public:
// base();
// ~base();
void init() {};
void inita(int x)
{
a = x;
}
int geta() { return a; }
private:
int a;
};
class Derived :public base { //public继承
public:
void init() {};
void initb(int y) { b = y; }
int getb() { return b*geta(); } //调用基类public成员
private:
int b;
};
class private_Derived :private base { //private继承方式
public:
void initc(int y, int x)
{
c = y;
//a = x; 不合法,因为a是基类private成员 ,不能直接访问
inita(x); //合法
}
int getc()
{
return c*geta();//调用基类成员函数
}
private:
int c;
};
//protected成员 :private继承或public继承,都需要通过函数接口访问,这样很不方便,因此出现了protected成员:可以被本类或派生类的成员函数访问,但不能被外部函数访问。
class pro_base {
public:
int a;
void setbc(int x, int y)
{
b = x;
c = y;
}
int getb() { return b; }
int getc() { return c; }
protected:
int b;
private:
int c;
};
//protected继承
class pbase_pro :/*protected*/ pro_base {
public:
void setbcp(int x, int y, int z)
{
b = x; //b可以直接访问
//c = y;//非法
setbc(x, y);
p = z;
}
int getp()
{
p = p + b*getc();
return p;
}
private:
int p;
};
//派生类直接访问基类成员:
//派生类不能直接访问基类private成员,若要访问必须使用基类的成员函数接口访问。但也是有方法的:
/*
直接访问基类private成员的方法有两种
1、增加基类protected成员。
2、将需要访问基类私有成员的派生类成员函数声明为友元。
*/
class fbase { //友元
public:
int x;
friend class Derived2;
protected:
int y;
private:
int z;
};
class Derived1 :virtual fbase {
public:
//int getz() { return z; } //非法,基类私有成员不可以直接访问
int gety() { return y; } //基类protected成员派生类可以直接访问。
int getx() { return x; }
};
class Derived2 :virtual fbase {
public:
void setz(int a) { z = a; } //直接访问
int getx();
int getz();
int gety();
};
int Derived2::getx()
{
return x;
}
int Derived2::getz()
{
return z;//友元可以直接访问基类private成员
}
int Derived2::gety()
{
return y; //基类protected成员可以被派生类直接访问
}
int main(int argc,char** argv)
{
/*Derived de;//public继承使用案例
de.inita(12);
de.initb(5);
cout << de.getb() << endl;
de.init();//默认调用派生类Derived中的init()
de.base::init();//要调用基类中的init()必须加base::init()限定。*/
/*private_Derived pd; //private继承使用案例
//pd.geta();//非法
pd.getc(); */
/*pbase_pro ob; //protected继承使用 案例
//ob.setbc();//非法,外部函数不可以直接访问 基类protected继承来的成员
ob.setbcp(1, 2, 3);//合法
cout << ob.getp()<<endl; */
int i(0);//友元使用案例
Derived2 fb;
fb.setz(6);
i = fb.getz();
cout << i << endl;
return 0;
}
//派生类(derived)分为单继承(inherit)和多继承。基类是对派生类的抽象,派生类是对基类的具体化,是基类的延续。派生类也可以看做是基类的组合(多继承)
//公有派生类的对象可以作为基类的对象处理。格式:class <派生类名称>:<继承方式><基类名>。继承方式:(virtual) private,public,protected.
/*
//继承的访问权限:
基类中的私有成员在派生类中是隐藏的,只能在基类内部访问,一般通过public函数访问
派生类中成员不能访问基类的private成员,但可以访问基类中的public和protected成员。
派生类从基类public继承时,基类的成员类型都不变,public\private\protected仍然是public\private\protected。
派生类从基类private继承时,基类的pbulic和protected成员都变成private成员。而基类的private成员不能被访问。
派生类从基类protected继承时,基类的public成员在派生类中变为protected成员,protected成员仍为protected成员。
*/
// //类和结构体的区别:类的成员默认为private,而结构体的成员默认为public
//关于继承:class的继承默认是private继承方式,而结构体是public继承方式
#include<iostream>
using namespace std;
class base
{
public:
// base();
// ~base();
void init() {};
void inita(int x)
{
a = x;
}
int geta() { return a; }
private:
int a;
};
class Derived :public base { //public继承
public:
void init() {};
void initb(int y) { b = y; }
int getb() { return b*geta(); } //调用基类public成员
private:
int b;
};
class private_Derived :private base { //private继承方式
public:
void initc(int y, int x)
{
c = y;
//a = x; 不合法,因为a是基类private成员 ,不能直接访问
inita(x); //合法
}
int getc()
{
return c*geta();//调用基类成员函数
}
private:
int c;
};
//protected成员 :private继承或public继承,都需要通过函数接口访问,这样很不方便,因此出现了protected成员:可以被本类或派生类的成员函数访问,但不能被外部函数访问。
class pro_base {
public:
int a;
void setbc(int x, int y)
{
b = x;
c = y;
}
int getb() { return b; }
int getc() { return c; }
protected:
int b;
private:
int c;
};
//protected继承
class pbase_pro :/*protected*/ pro_base {
public:
void setbcp(int x, int y, int z)
{
b = x; //b可以直接访问
//c = y;//非法
setbc(x, y);
p = z;
}
int getp()
{
p = p + b*getc();
return p;
}
private:
int p;
};
//派生类直接访问基类成员:
//派生类不能直接访问基类private成员,若要访问必须使用基类的成员函数接口访问。但也是有方法的:
/*
直接访问基类private成员的方法有两种
1、增加基类protected成员。
2、将需要访问基类私有成员的派生类成员函数声明为友元。
*/
class fbase { //友元
public:
int x;
friend class Derived2;
protected:
int y;
private:
int z;
};
class Derived1 :virtual fbase {
public:
//int getz() { return z; } //非法,基类私有成员不可以直接访问
int gety() { return y; } //基类protected成员派生类可以直接访问。
int getx() { return x; }
};
class Derived2 :virtual fbase {
public:
void setz(int a) { z = a; } //直接访问
int getx();
int getz();
int gety();
};
int Derived2::getx()
{
return x;
}
int Derived2::getz()
{
return z;//友元可以直接访问基类private成员
}
int Derived2::gety()
{
return y; //基类protected成员可以被派生类直接访问
}
int main(int argc,char** argv)
{
/*Derived de;//public继承使用案例
de.inita(12);
de.initb(5);
cout << de.getb() << endl;
de.init();//默认调用派生类Derived中的init()
de.base::init();//要调用基类中的init()必须加base::init()限定。*/
/*private_Derived pd; //private继承使用案例
//pd.geta();//非法
pd.getc(); */
/*pbase_pro ob; //protected继承使用 案例
//ob.setbc();//非法,外部函数不可以直接访问 基类protected继承来的成员
ob.setbcp(1, 2, 3);//合法
cout << ob.getp()<<endl; */
int i(0);//友元使用案例
Derived2 fb;
fb.setz(6);
i = fb.getz();
cout << i << endl;
return 0;
}