精华内容
下载资源
问答
  • 私有继承
    2022-03-17 10:28:56

    私有继承是C++另一种实现has-a(包含)关系的途径。使用私有继承,基类的公有成员和保护成员都将成为派生类的私有成员。这意味着基类方法将不会成为派生对象公有接口的一部分,但可以在派生类的成员函数中使用它们。

    下面,我们用Student类私有继承标准库中的std::string类:

    // studenti.h -- defining a Student class using private inheritance
    #include <iostream>
    #include <string>
    class Student : private std::string {
     public:
    	Student() : std::string("Null Student") {}
    	bool HaveMyCountry(const std::string& str) const;
        void Append(const std::string& str);
    	const std::string& Name() const;
    	friend std::istream& operator>>(std::istream & is, Student & stu);
    };
    // studenti.cpp -- Student class using private inheritance
    #include "studenti.h"
    using std::istream;
    using std::string;
    bool Student::HaveMyCountry(const string& str) const {
    	if (string::size() > 0) {
    		std::size_t found = string::find(str);
    		if (found != std::string::npos)
    			return true;
    	}
    	return false;
    }
    void Student::Append(const std::string& str) {
    	string::append(str);
    }
    const string& Student::Name() const {
    	return (const string&)*this;
    }
    istream& operator>>(istream& is, Student& stu) {
    	is >> (string&)stu;
    	return is;
    }
    // use_stui.cpp -- using a class with private inheritance
    // compile with studenti.cpp
    #include <iostream>
    #include "lacks.h"
    using std::cin;
    using std::cout;
    using std::endl;
    const int SIZE = 3;
    const std::string MY_COUNTRY = "China";
    int main() {
    	Student stuArr[SIZE] = { Student(), Student(), Student() };
    	cout << "Please enter the country's name: ";
    	for (int i = 0; i < SIZE; i++) {
    		cin >> stuArr[i];
    	}
    	for (int i = 0; i < SIZE; i++) {
    		Student stu = stuArr[i];
    		cout << stu.Name() << " contains my country name:" << (stu.HaveMyCountry(MY_COUNTRY) ? "Yes" : "No") << endl;
    	}
    	stuArr[SIZE -1].Append(MY_COUNTRY);
    	cout << "After do an append to the last country: " << endl;
    	cout << stuArr[SIZE -1].Name() << " contains my country name:" << (stuArr[SIZE -1].HaveMyCountry(MY_COUNTRY) ? "Yes" : "No") << endl;
    	return 0;
    }
    Please enter the country's name: |AmericanMan ChinaBank RussiaBeer<Enter>
    AmericanMan contains my country name:No
    ChinaBank contains my country name:Yes
    RussiaBeer contains my country name:No
    After do an append to the last country: 
    RussiaBeerChina contains my country name:Yes

    如果私有继承都不能访问基类的一切的话,那继承还有个什么意思!所以一定是有方法可以去调用基类的公有数据的!

    这不:私有继承使得能够使用类名和作用域解析运算符来调用基类的公有方法。

    对于继承类,代码中构造函数将使用成员初始化列表语法,它使用类名而不是成员名来标识构造函数:

    Student() : std::string("Null Student") {}

    Student类的默认构造函数调用了基类std::string类的构造函数:string (const char* s); 以完成基类成员的初始化。

    派生类使用了基类的公有方法size()、find()、append()和公有静态成员常量npos。私有继承也是可以调用基类的公有成员和方法的,不同于公有继承的是,要使用类名和作用域解析运算符来调用,正如代码中看到的那样。

    要使用基类对象本身,该如何做呢?使用私有继承时,该string对象没有名称。答案是使用强制类型转换,正如代码中看到的那样。由于Student类是从string类派生而来的,因此可以通过强制类型转换,将Student对象转换为string对象;结果为继承而来的string对象。

    更多相关内容
  • C++ 中私有继承的作用

    2020-12-25 19:16:39
    C++ 中私有继承的作用 私有继承的 第一个规则:和公有继承相反,如果两个类之间的继承关系为私有,编译器一般不会将派生类对象转换成基类对象。 第二个规则: 从私有基类继承而来的成员都成为了派生类的私有成员,...
  • C/C++ 公有继承、保护继承和私有继承的区别  在c++的继承控制中,有三种不同的控制权限,分别是public、protected和private。定义派生类时,若不显示加上这三个关键字,就会使用默认的方式,用struct定义的类是默认...
  • 在c++的继承控制中,有三种不同的控制权限,分别是public、protected和private。定义派生类时,若不显示加上这三个关键字,会使用默认的方式,用struct定义的类是默认public继承,class定义的类是默认private继承。...
  • 主要介绍了详解C++编程中的私有继承和公有继承,是C++入门学习中的基础知识,需要的朋友可以参考下
  • 私有继承

    2021-03-23 10:19:42
    使用私有继承,那么基类的共有成员和保护成员都成了派生类的私有成员,基类的公有方法 将成为 派生类的私有方法 一个私有继承的例子 class STUDENT : private std::string, private std::valarray<double> { ...

    使用私有继承,那么基类的共有成员和保护成员都成了派生类的私有成员,基类的公有方法 将成为 派生类的私有方法


    一个私有继承的例子

    class STUDENT : private std::string, private std::valarray<double>
    {
    
    };
    

    一个Student类 私有继承了 string 和 valarray
    这个私有继承 提供了两个无名的子对象成员


    那么对于私有继承,我们如何用构造函数进行初始化呢?

    class STUDENT : private std::string, private std::valarray<double>
    {
    public:
         STUDENT(const std::string& a , int n);
    };
    
    STUDENT::STUDENT(const std::string& a, int n) :std::string(a), 
    std::valarray<double>(n)
    {
    
    }
    

    我们是用初始化列表 + 类名来 进行构造函数,而不是成员名,因为他两是无名成员


    如何访问基类的方法呢

    被私有继承后,基类的公有成员,保护成员都成了派生类的私有成员,
    所以只能在派生类的方法中使用基类的方法

    class STUDENT : private std::string, private std::valarray<double>
    {
         typedef std::valarray<double> ArrayDb;
    public:
         STUDENT(const std::string& a , int n);
         int StrSize(void) const;
    };
    
    int STUDENT::StrSize(void) const
    {
         return std::string::size();
    }
    

    使用类名+作用于解析运算符 来进行访问 基类的方法

    如何访问基类本身

    答案是 使用强制类型转化

     std::string str = "zhu";
     STUDENT a(str, 10);
     std::cout << (std::string &)a << std::endl;
    
    展开全文
  • c++——私有继承

    千次阅读 2020-11-05 14:36:54
    私有继承:使用私有继承,基类的公有成员和保护成员都将成为派生类的私有成员,只可以在派生类的成员函数中使用 一、私有继承示例 class Student : private std::string,private std::valarray<double> { ...

    私有继承:使用私有继承,基类的公有成员和保护成员都将成为派生类的私有成员,只可以在派生类的成员函数中使用
    一、私有继承示例

    class Student : private std::string,private std::valarray<double>
    {
    public:
     ...
    }
    //student以私有继承的方式继承了string类和valarray类
    //stduent是多重继承(使用多个基类的继承被称为多重继承)
    

    示例student类

    class Student
    {
    private:
    	typedef std::valarray<double> ArrayDb;//可以在student类的实现中使用,类外不可以
    	std::string name;
    	ArrayDb scores;
    	std::ostream & arr_out(std::ostream & os) const;
    public:
    	Student(): name("NULL Student"),scores() {}
    
    	//explicit 防止单参数的构造函数的隐式转换
    	explicit Student(const std::string & s) : name(s),scores() {}  //explicit 表示该构造函数是显示的,只能修饰一个参数的构造函数
    	explicit Student(int n) : name("Nully"),scores(n) {}
    	Student (const std::string & s,int n) : name(s),scores(n) {}
    	Student (const std::string & s,const ArrayDb & a) : name(s),scores(a) {}
    	Student (const char * str,const double * pd,int n) : name(str),scores(pd,n) {}
    	~Student() {}
    	double Average() const;
    	const std::string & Name() const;
    	double & operator[](int i);
    	double operator[](int i) const;
    
    	friend std::istream & operator>>(std::istream & is,Student & stu);//重载输入
    	friend std::istream & getline(std::istream & is,Student & stu);
    	friend std::ostream & operator<<(std::ostream & os,const Student & stu);//重载输出
    };
    

    1.初始化类的区别

    公有继承的构造函数初始化
    Student(const char *str,const double *pd,int n) : name(str),scores(pd,n){}
    
    私有继承的构造函数初始化
    Student(const char * str,const double *pd,int n) :std::string(str),ArrayDb(pd,n){}
    []1.私有继承使用成员初始化列表方法时,使用类名而不是成员名来初始化标识构造函数。
         2.在私有继承中,在不进行显示类型转换的情况下,不能将指向派生类的引用或者指针赋给基类引用或指针。
    

    2.私有继承demon

    #include<iostream>
    #include<string>
    #include<valarray>
    
    using std::ostream;
    using std::endl;
    using std::istream;
    using std::string;
    
    class Student : private std::string, private std::valarray<double>
    {
    private:
    	typedef std::valarray<double> ArrayDb;//可以在student类的实现中使用,类外不可以
    	std::ostream & arr_out(std::ostream & os) const;
    public:
    	Student() : std::string("Null student"),ArrayDb() {}
    	explicit Student(const std::string & s) : std::string(s),ArrayDb() {}
    	explicit Student(int n) : std::string("Nully"),ArrayDb(n) {}
    	Student(const std::string & s,int n) : std::string(s),ArrayDb(n) {}
    	Student(const char *str,const double *pd,int n) : std::string(str),ArrayDb(pd,n) {}
    	~Student() {}
    	
    	double Average() const;
    	double & operator[](int i); //适用于对象
    	double operator[](int i) const; //适用于取值
    	const std::string & Name() const;
    
    	friend std::istream & operator>>(std::istream & is,Student & stu);
    	friend std::istream & getline(std::istream & is,Student & stu);
    	friend std::ostream & operator<<(std::ostream & os,const Student & stu);
    };
    
    //类的实现
    double Student::Average() const
    {
    	if(ArrayDb::size() > 0)
    		return ArrayDb::sum()/ArrayDb::size();
    	else
    		return 0;
    }
    
    const string & Student::Name() const
    {
    	return (const string &)*this;
    }
    
    double & Student::operator[](int i)
    {
    	return ArrayDb::operator[](i);
    }
    
    double Student::operator[](int i) const
    {
    	return ArrayDb::operator[](i);
    }
    
    //私有类函数方法,调整打印格式
    ostream & Student::arr_out(ostream & os) const
    {
    	int i;
    	int lim = ArrayDb::size();
    	if(lim > 0)
    	{
    		for(i = 0; i < lim; i++)
    		{
    			os << ArrayDb::operator[](i) << "	";//对 [] 进行了重载
    			if(i % 5 == 4)
    				os << endl;
    		}
    		if( i % 5 != 0)
    			os<< endl;
    	}
    	else
    		os << "empty array";
    	return os;
    }
    
    
    istream & getline(istream & is,Student & stu)
    {
    	getline(is,(string &)stu);
    	return is;
    }
    
    ostream & operator<<(ostream & os,const Student & stu)
    {
    	os << (const string &)stu <<"同学的成绩:\n";
    	stu.arr_out(os);
    	return os;
    }
    
    using std::cin;
    using std::cout;
    
    void set(Student & sa,int n);
    const int pupils = 3;
    const int quizzes = 5;
    
    int main()
    {
    	Student ada[pupils] = { Student(quizzes),Student(quizzes),Student(quizzes)};
    	int i;
    	for (i = 0;i < pupils; ++i)
    		set(ada[i],quizzes);
    	cout<< "\n Studnet List:\n";
    
    	for(i = 0; i < pupils; ++i)
    		cout << ada[i].Name() << endl;
    	
    	cout << "\n 学生信息:";
    	for(i = 0; i < pupils; i++)
    	{
    		cout << ada[i] <<endl;
    		cout << "平均成绩:" << ada[i].Average() << endl;
    	}
    
    	cout << " Done\n" << endl;
    	return 0;
    }
    
    void set(Student & sa,int n)
    {
    	cout << "请输入学生名:";
    	getline(cin,sa);
    	cout << "请输入学 " << n <<"项成绩:\n";
    	for(int i = 0; i < n; i++)
    		cin >> sa[i]; //因为对 & [] 进行了重载,所以这里可以将成绩输入到socres数组中
    	while(cin.get() != '\n')
    		continue;
    }
    

    运行结果:
    在这里插入图片描述
    公有继承实现:

    #include<iostream>
    #include<string>
    #include<valarray>
    
    class Student
    {
    private:
    	typedef std::valarray<double> ArrayDb;//可以在student类的实现中使用,类外不可以
    	std::string name;
    	ArrayDb scores;
    	std::ostream & arr_out(std::ostream & os) const;
    public:
    	Student(): name("NULL Student"),scores() {}
    
    	//explicit 防止单参数的构造函数的隐式转换
    	explicit Student(const std::string & s) : name(s),scores() {}  //explicit 表示该构造函数是显示的,只能修饰一个参数的构造函数
    	explicit Student(int n) : name("Nully"),scores(n) {}
    	Student (const std::string & s,int n) : name(s),scores(n) {}
    	Student (const std::string & s,const ArrayDb & a) : name(s),scores(a) {}
    	Student (const char * str,const double * pd,int n) : name(str),scores(pd,n) {}
    	~Student() {}
    	double Average() const;
    	const std::string & Name() const;
    	double & operator[](int i);
    	double operator[](int i) const;
    
    	friend std::istream & operator>>(std::istream & is,Student & stu);//重载输入
    	friend std::istream & getline(std::istream & is,Student & stu);
    	friend std::ostream & operator<<(std::ostream & os,const Student & stu);//重载输出
    };
    
    
    //类的实现
    using std::ostream;
    using std::endl;
    using std::istream;
    using std::string;
    
    //平均分
    double Student::Average() const
    {
    	if(scores.size() > 0)
    		return scores.sum()/scores.size();
    	else
    		return 0;
    }
    
    const string & Student::Name() const
    {
    	return name;
    }
    
    double & Student::operator[](int i) 
    {
    	return scores[i];
    }
    
    double Student::operator[](int i) const
    {
    	return scores[i];
    }
    
    //私有类函数方法,调整打印格式
    ostream & Student::arr_out(ostream & os) const
    {
    	int i;
    	int lim = scores.size();
    	if(lim > 0)
    	{
    		for(i = 0; i < lim; i++)
    		{
    			os << scores[i] << "	";
    			if(i % 5 == 4)
    				os << endl;
    		}
    		if( i % 5 != 0)
    			os<< endl;
    	}
    	else
    		os << "empty array";
    	return os;
    }
    
    istream & operator>>(istream & is,Student & stu)
    {
    	is >> stu.name;
    	return is;
    }
    
    istream & getline(istream & is,Student & stu)
    {
    	getline(is,stu.name);
    	return is;
    }
    
    ostream & operator<<(ostream & os,const Student & stu)
    {
    	os << " Scores for " << stu.name << " :\n";
    	stu.arr_out(os);
    	return os;
    }
    
    using std::cin;
    using std::cout;
    
    void set(Student & sa,int n);
    const int pupils = 3;
    const int quizzes = 5;
    
    int main()
    {
    	Student ada[pupils] = { Student(quizzes),Student(quizzes),Student(quizzes)};
    	int i;
    	for (i = 0;i < pupils; ++i)
    		set(ada[i],quizzes);
    	cout<< "\n Studnet List:\n";
    
    	for(i = 0; i < pupils; ++i)
    		cout << ada[i].Name() << endl;
    	
    	cout << "\n 学生信息:";
    	for(i = 0; i < pupils; ++i)
    	{
    		cout << ada[i] <<endl;
    		cout << "平均成绩:" << ada[i].Average() << endl;
    	}
    
    	cout << " Done\n" << endl;
    	return 0;
    }
    
    void set(Student & sa,int n)
    {
    	cout << "请输入学生名:";
    	getline(cin,sa);
    	cout << "请输入学 " << n <<"项成绩:\n";
    	for(int i = 0; i < n; i++)
    		cin >> sa[i]; //因为对 [] 进行了重载,所以这里可以将成绩输入到socres数组中
    	while(cin.get() != '\n')
    		continue;
    }
    
    

    二、保护继承
    保护继承:保护继承是私有继承的变体,保护继承在列出基类时使用关键字protected

    class Student : protected std::string,protected std::valarray<double>
    {...};
    //保护继承时,基类的公有成员都将变成派生类的保护成员。和私有继承一样,基类的接口在派生类中也可用,继承层次之外不可用。
    //在派生类中,保护继承无需显示类型转换,就可以将基类的指针或引用指向派生类对象。
    

    三、使用using重新定义访问权限
    实现:使用派生或私有派生时,基类的公有成员将成为保护成员或私有成员。实现基类的方法在派生类中可用,可以定义一个使用该基类方法的派生类方法。
    法一:定义一个使用该基类方法的派生类方法

    double Student::sum() const
    {
    	return std::valarry<double>::sum();
    }
    

    法二:将函数调用包装在另一个函数调用中,即使用一个using声明来指出派生类可以使用特定的基类成员,即使用的是私有派生

    class Student : private std::string,private std::valarray<double>
    {
    ...
    public:
    	using std::valarray<double>::min;
    	using std::valarray<double>::max;
    	...
    };
    
    
    //使用
    cout << "high score: " << ada[i].max() << endl;
    []1.using声明只使用成员名——没有圆括号、函数特征标和返回类型。
    	 2.using声明只适用于继承,不适用于包含
    

    法三:将方法名放在派生类的公有部分

    class Student : private std::string,private std::valarry<double>
    {
    ...
    public:
    	std::valarry<double>::operator[];//redeclare as public,just use name
    }
    //法三需要编译器的支持,因为此方法即将摒弃
    
    展开全文
  • 保护继承与私有继承

    2021-06-13 18:05:28
    在保护继承方式中,基类的公有成员和保护成员被派生类继承后变成派生类的保护成员,而基类的私有成员在派生类中不能访问。 因为基类的公有成员和保护成员在派生类中都成了保护成员,所以派生类的新增成员可以直接...

    保护继承

    在保护继承方式中,基类的公有成员和保护成员被派生类继承后变成派生类的保护成员,而基类的私有成员在派生类中不能访问。

    因为基类的公有成员和保护成员在派生类中都成了保护成员,所以派生类的新增成员可以直接访问基类的公有成员和保护成员,而派生类的对象不能访问它们,类的对象也是处于类外的,不能访问类的保护成员。对基类的私有成员,派生类的新增成员函数和派生类对象都不能访问。

    通过上述保护继承的讲解,相信大家对类的保护成员的访问属性有更加深刻的理解了。

    假设A类是基类,B类是从A类继承的派生类,A类中有保护成员,则对派生类B来说,A类中的保护成员和公有成员的访问权限是一样的。

    而对A类的对象的使用者来说,A类中的保护成员和私有成员都一样不能访问。可见类中的保护成员可以被派生类访问,但是不能被类的外部对象(包括该类的对象、一般函数、其他类等)访问。

    我们可以利用保护成员的这个特性,在软件开发中充分考虑数据隐藏和共享的结合,很好的实现代码的复用性和扩展性。

    举个简单的例子讨论下保护成员的访问属性。

    class Base
    {
    protected:
        int x;        // 基类的保护成员
    };
    int main()
    {
        Base base;
        base.x = 0;   // 编译报错
        return 0;
    }
    

    这段代码在编译的时候会报错,错误就出在通过对象base访问保护成员x时,就像上面讲的,对Base类的对象base的使用者来说,Base类中的保护成员x和私有成员的访问特性是一样的,所以对象base不能访问x,这样跟使用私有成员一样通过保护成员实现了数据的隐藏。

    class Base
    {
    protected:
        int x;       // 基类的保护成员
    };
    class Child : public Base
    {
    public:
        void InitX();
    };
    void Child::InitX()
    {
        x = 0;
    }
    

    对上面的派生类Child来说,基类Base中的保护成员x和公有成员的访问权限一样,所以Child类的成员函数InitX可以访问Base类的保护成员x。

    私有继承

    在私有继承方式中,基类的公有成员和保护成员被派生类继承后变成派生类的私有成员,而基类的私有成员在派生类中不能访问。

    派生类的新增成员可以直接访问基类的公有成员和保护成员,但是在类的外部通过派生类的对象不能访问它们。而派生类的成员和派生类的对象都不能访问基类的私有成员。

    讲到这里,我们看到不管是保护继承还是私有继承,在派生类中成员的访问特性都是一样的,都是基类的公有和保护成员可以访问,私有成员不能访问。

    但是派生类作为基类继续派生新类时,两种继承方式就有差别了。

    例如,A类派生出B类,B类又派生出C类,如果B类是以保护继承方式从A类继承的,则A类的公有成员和保护成员都成为B类的保护成员,再由B类派生出C类时,原来A类的公有成员和保护成员间接继承到C类中,成为C类的保护成员或者私有成员(C类从B类公有继承或保护继承时为前者,私有继承时为后者),所以C类的成员可以间接访问A类的公有成员和保护成员。

    但是如果B类是以私有继承方式从A类继承的,则A类的公有成员和保护成员都成为B类的私有成员,A类的私有成员不能在B类中访问,B类再派生出C类时,原来A类的所有成员都不能在C类中访问。

    由以上分析得出,私有继承使得基类的成员在其派生类后续的派生中不能再被访问,中止了基类成员继续向下派生,这对代码的复用性没有好处,所以一般很少使用私有继承方式。

    将上一讲中的例子由公有继承改为私有继承,继而更形象的说明私有继承的特性。

    #include <iostream>
    using namespace std;
    class Base            // 基类Base的声明
    {
    public:               // 公有成员函数
        void SetTwo(int a, int b)  { x=a; y=b; }
        int GetX()   { return x; }
        int GetY()   { return y; }
    private:              // 私有数据成员
        int x;
        int y;
    };
    class Child : private Base    // 派生类的声明,继承方式为私有继承
    {
    public:                      // 新增公有成员函数
        void SetThree(int a, int b, int c)  { SetTwo(a, b); z=c; }
        int GetX()   { return Base::GetX(); }
        int GetY()   { return Base::GetY(); }
        int GetZ()   { return z; }
    private:                     // 新增私有数据成员
        int z;
    };
    int main()
    {
        Child child;           // 声明Child类的对象
        child.SetThree(1, 2, 3); // 设置派生类的数据
        cout << "The data of child:"<<endl;
        cout << child.GetX() << "," << child.GetY() << "," << child.GetZ() << endl;
        return 0;
    }
    

    在这里插入图片描述
    Child类从Base类中私有继承,Base类中的公有成员SetTwo()、GetX()和GetY()成为Child类的私有成员,在Child类中可以直接访问它们,例如Child类的成员函数SetThree()中直接调用了Base类的公有成员函数SetTwo()。

    Base类的私有成员x和y在Child类中不能访问。在外部通过Child类的对象不能访问Base类的任何成员,因为Base类的公有成员成为Child类的私有成员,Base类的私有成员在Child类中不能访问。

    那么Base类的作为外部接口的公有成员SetTwo()、GetX()和GetY()都被派生类Child隐藏起来,外部不能通过Child类的对象直接调用。

    如果我们希望派生类也提供跟基类中一样的外部接口怎么办呢?我们可以在派生类中重新定义重名的成员。

    上面的Child类就重新定义了公有成员函数GetX()和GetY(),函数体则只有一个调用基类函数的语句,照搬了基类函数的功能。

    因为派生类中重新定义的成员函数的作用域位于基类中同名函数的作用域范围的内部,根据前面可见性中讲的同名覆盖原则,调用时会调用派生类的函数。

    通过这种方式可以对继承的函数进行修改和扩展,在软件开发中经常会用到这种方法。

    大家可能发现,main函数的函数体跟上一讲例子中的完全相同,但实际上在程序执行的时候是不同的,这里调用的函数GetX()和GetY()都是派生类Child的函数,由于是私有继承,基类Base中的同名函数都不能通过Child类的对象访问。

    这个例子跟上一讲的例子相比,Base类和主函数main的函数体都没有修改,只修改了派生类Child的声明,但Child类的外部接口没有改变。

    到此大家有没有认识到面向对象设计封装性的优越性?我们可以根据需要调整类的内部数据结构,但只要保持外部接口不变,那我们做的类的内部调整对外部就是透明的,不会影响到程序的其他部分。这充分体现了面向对象设计的可维护性和可扩展性。

    展开全文
  • 公有继承:基类成员在派生类中的成员属性不会变化,可访问基类中的public成员和protect成员,不能直接访问基类中的private成员,但可通过共有成员函数访问。 #include<iostream> using namespace std; //...
  • 1.在声明一个派生类时将基类的继承方式指定为public,称为公有继承。 2.用公有继承方式建立的派生类称为公有派生类,其基类称为公有基类 例,公有继承的测试 #include<iostream> using namespace std ; class...
  • 公有继承/私有继承/保护继承的区别

    千次阅读 2020-05-16 01:07:37
    公有继承时,对基类的公有成员和保护成员的访问属性不变,派生类的新增成员可以访问基类的公有成员和保护成员,但是访问不了基类的私有成员。派生类的对象只能访问派生类的公有成员(包括继承的公有成员),访问不了...
  • 不同的继承方式主要体现在以下两个方面: 派生类成员对于基类的访问权限 (类内) 通过派生类对象对基类成员的访问权限(类外)
  • 对于私有继承,在派生类中,基类的公有成员、私有成员和保护成员的访问控制属性均变为私有。在派生类的函数中,可以访问基类的公有成员和保护成员。但无法通过派生类对象访问从基类继承过来的成员。(即基类中的所有...
  • C++公有继承,保护继承,私有继承的区别

    万次阅读 多人点赞 2018-08-21 15:34:32
    公有继承时,对基类的公有成员和保护成员的访问属性不变,派生类的新增成员可以访问基类的公有成员和保护成员,但是访问不了基类的私有成员。派生类的对象只能访问派生类的公有成员(包括继承的公有成员),访问不了...
  • 公有继承,保护继承和私有继承

    千次阅读 2020-08-30 17:28:20
    C++继承:公有继承、保护继承、私有继承2 公有继承 公有继承时,对基类的共有成员和保护成员的访问属性不变,派生类的新增成员可以访问基类的公有成员和保护成员,但是访问不了基类的私有成员。派生类的对象只能...
  • C++之共有继承、保护继承、私有继承 - 唯一诺 - 博客园 定义如下类,会引起编译器报错的是() class Base { public: int base_public; protected: int base_protect; private: int base_private; }; ...
  • C++中public继承、private继承、protected继承的例子
  • 就class之间的关系做一个简单的定义,继承base class的class,base class可以认为class都是自己的子女。 1、public:public表明该数据成员、成员函数是对所有用户开放的,所有用户都可以直接进行调用 2、private:...
  • 第一次学私有继承的时候非常迷惑,感觉既然都是不可见,不就是说啥都干不了吗?然后这两天了解到了这方面的知识,总结如下。 有什么用 最大的用处是通过“继承”的纵向逻辑建立了一种“has-a”逻辑。更直白点说,...
  • 一个子类继承父类时,可按照public、private和protected方式继承父类,每种继承方式的区别如下:   1) public继承方式 基类中所有public成员在派生类中为public属性; 基类中所有protected成员在派生类中为...
  • 首先,我们先来看一下C++中类成员的访问范围说明符public,...与private只在继承时访问范围有区别。详细解释见下文。 private 用来指定私有成员。一个类的私有成员,不论是成员变量还是成员函数,都只有在该类...
  • 私有继承的一些作用

    2019-01-04 13:19:13
    先给结论: 1.private继承就是一种纯粹的实现技术 : 意味着老子继承你,...一般来说私有继承,与复合类的作用类似,可以互换(复合类更容易理解) 3.这个新的类将不会与父类指针有关系(接口都变private了) 与public继...
  • 继承:是面向对象程序设计的一个重要机制,该机制自动地为一个类提供来自另一个类的操作和数据结构,这使得  程序员只需在新类中定义已有类中没有的成员来建立新类。也就是说:新类不但可以共享原有类的属性,  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 317,054
精华内容 126,821
关键字:

私有继承

友情链接: extract_bufr_data.zip