继承最主要的作用是实现多态
*无论是哪种继承,对象都不能访问父类的私有成员
公有继承
#include <iostream>
using namespace std;
class base
{
private:
int x;
};
class D : public base //D公有继承父类base
{
public:
int y;
};
int main()
{
cout << sizeof(D) << endl; //大小为8字节,说明子类继承父类时
//不仅仅只继承父类的公有部分,推翻之前的只继承父类公有部分的说法
return 0;
}
#include <iostream>
using namespace std;
class base
{
public:
base() : x(0)
{}
~base(){}
public:
void show_base()
{
cout << "base :: show_base()!" << endl;
}
public:
void SetX(int data)
{
x = data;
}
protected: //保护属性只有在继承中才可以体现其作用
void print_base()
{
cout << "base :: print_base()!" << endl;
}
private:
int x;
};
//公有继承:
// 相当于把父类的所有信息(除了父类的构造和析构函数)全部继承,
// 父类的私有,公有,保护继承到子类后仍维持之前的属性
//
//对于派生类(子类)内部:
// 对于父类的私有成员无论什么继承方式,子类都不可直接访问,要通过父类的保护或公有方法进行访问
// 公有继承不可以直接访问父类的私有成员,但可以直接访问父类的公有和保护成员
//
//对于对象:
// 公有继承时父类的保护成员不可以直接访问
// 通过对象永远只能访问公有方法;保护和私有永远不可通过对象访问
//
class D : public base //D公有继承父类base
{
public:
D() : y(0)
{}
~D()
{}
public:
void setdata(int data)
{
y = data; //ok,D的公有方法访问自己的私有数据
//x = data; //不可以,虽然D继承了父类相当于D也拥有x成员,
//但是不能直接对父类的私有成员操作,
SetX(data); //要想访问父类的私有成员必须通过父类的公有方法(无论哪种继承方式)
}
public:
void show_D()
{
cout << "D :: show_D()!" << endl;
show_base(); //子类可以直接调用父类的公有方法
}
protected:
void print_D()
{
cout << "D :: print()_D" << endl;
}
private:
int y;
};
//划分为两个层次
//1.派生类内部能否访问父类
//2.对象能否访问
int main()
{
base b; //b不可直接访问其私有数据(要通过公有方法)
//b不可调用其保护方法,只能调用其公有方法
//针对派生子类
D d;
d.show_base(); //可以访问
d.show_D(); //可以访问
//d.print_base(); //d对象不可以访问父类的保护成员
//d.print_D(); //d对象不可以访问子类的保护成员
cout << sizeof(D) << endl; //大小都为8字节,无论是公有,保护还是私有继承父类
return 0;
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
保护继承
#include <iostream>
using namespace std;
class base
{
public:
base() : x(0)
{}
~base(){}
public:
void show_base()
{
cout << "base :: show_base()!" << endl;
}
public:
void SetX(int data)
{
x = data;
}
protected:
void print_base()
{
cout << "base :: print_base()!" << endl;
}
private:
int x;
};
//保护继承:
// 保护继承时,相当于将父类的除去构造和析构的所有信息都继承,
// 不过继承为子类的保护成员(原先的保护和公有)(原先的私有保护继承后仍为私有)
//对于派生类内部:
// 子类不能访问父类的私有成员
// 子类可以访问父类的公有和保护成员
//
//对于对象:
// 子类对象可以访问自身的公有成员,
// 但子类对象不可访问父类的公有成员
//
class D : protected base //此处的继承方式针对的是对象的操作的限制
{
public:
D() : y(0)
{}
~D()
{}
public:
void setdata(int data)
{
y = data; //ok,D的公有方法访问自己的私有数据
}
public:
void show_D()
{
cout << "D :: show_D()!" << endl;
show_base(); //保护继承,可以访问父类的公有成员
print_base(); //保护继承,可以访问父类的保护成员
}
protected:
void print_D()
{
cout << "D :: print()_D" << endl;
}
private:
int y;
};
//划分为两个层次
//1.派生类内部能否访问父类
//2.对象能否访问
int main()
{
D d;
d.show_D(); //可以
//d.show_base(); //不可以访问,对于子类该方法是保护属性,子类对象不可访问父类的保护成员
}
私有继承
#include <iostream>
using namespace std;
class base
{
public:
base() : x(0)
{}
~base(){}
public:
void show_base()
{
cout << "base :: show_base()!" << endl;
}
public:
void SetX(int data)
{
x = data;
}
protected:
void print_base()
{
cout << "base :: print_base()!" << endl;
}
private:
int x;
};
//私有继承:
// 相当于将父类的所有信息(除去构造和析构)都拷贝至子类的私有部分
//
//对于派生类内部:
// 私有继承仅仅是将父类的成员当作i是子类的私有成员,但是访问方式仍不变
//
//对于对象:
// 父类的所有信息都不可访问(包括公有和保护成员);因为父类的一切对于子类对象来说都是私有的,所以子类对象不可直接访问
class D : private base //此处的继承方式针对的是对象的操作的限制
{
public:
D() : y(0)
{}
~D()
{}
public:
void setdata(int data)
{
y = data; //ok,D的公有方法访问自己的私有数据
}
public:
void show_D()
{
cout << "D :: show_D()!" << endl;
show_base(); //可以访问,虽然继承下来后作为子类的私有成员,
//但是子类的公有方法可以访问其私有成员
print_base(); //也可以访问父类的保护成员(原因同上)
}
protected:
void print_D()
{
cout << "D :: print()_D" << endl;
}
private:
int y;
};
//私有继承的用处:
// C公有继承了D,D私有继承了base,但base在D中是私有属性,C继承了D之后,
// C不能直接访问base,因为在D内base相当于D的私有成员,
// 所以对C来说无法访问父类D的私有成员;
//
class C : public D
{
public:
void show_C()
{
//show_base(); //不可访问(私有继承(多重继承时)),但可以在保护和公有继承时访问
}
}
//划分为两个层次
//1.派生类内部能否访问父类
//2.对象能否访问
int main()
{
D d;
}