精华内容
下载资源
问答
  • 派生解析:探索“派生解析”
  • 派生

    2020-06-02 21:12:55
    这里写目录标题派生派生,为什么要派生?类型转换派生类的构造函数派生类的析构函数派生类的访问当派生类中与基类有相同成员时:当派生类中无与基类有相同成员时: 派生派生,为什么要派生? 派生的目的: 当新...

    派生,为什么要派生?

    派生的目的
    当新问题出现,原有的程序无法解决或者无法完全解决时,需要对原有的程序进行改造。
    单继承时派生的定义:语法:class 派生类名:继承方式 基类名
    继承方式:
    继承方式存在三种,分别是公有继承,私有继承和保护继承。
    公有继承:基类的public和protected成员访问属性在派生类中保持不变,基类的private成员不可直接访问。
    私有继承:基类的public和protected成员以private身份出现在派生类中。
    保护继承:基类的public和protected成员以protected身份出现在派生类中,基类的private成员不可直接访问。派生类中的成员函数可以直接访问基类中的public和protected成员,但不能访问基类的private成员。通过派生类的对象不能直接访问从基类继承的任何成员。

    类型转换

    公有派生类对象可以被当做基类的对象使用,反之不可。因为公有派生类继承了基类的东西,即派生类的内容比基类只多不少,基类的对象访问接口和派生类的一样,因此可以直接当做基类的对象使用。
    派生类的对象可以隐含转化为基类对象
    派生类的对象可以初始化基类的引用
    派生类的指针可以隐含转化为基类的指针
    通过基类的对象名,指针只能使用从基类继承的成员

    派生类的构造函数

    默认情况下:基类的构造函数不能被继承,派生类需要自己定义构造函数。当基类有默认构造函数时,派生类构造函数可以不向基类传递参数,创建派生类的对象时,基类的默认构造函数被调用。而派生类继承的需要初始参数的基类成员函数会由派生类传递参数给基类,再由基类的构造函数初始化这些成员函数,而派生类新增部分的初始化由函数体和初始化列表完成。
    (c++11可以使用using语句继承基类的构造函数,但只能初始化从基类继承的成员:
    using 基类名 ::基类构造函数名)

    单继承时派生类构造函数语法:
    派生类名::派生类名(基类初始化所需的形参,本类成员所需的形参):基类名(参数表),
    本类成员初始化列表
    {
    其他初始化
    }
    如下Base2中的构造函数:

    #include<iostream>
    using namespace std;
    class Base1{
    	public:
    		Base1(){
    			b=0;
    			cout<<"Base1 is constructed..."<<endl;
    		}
    		Base1(int i){
    			b=i;
    			cout<<"Base1 is constructed..."<<endl;
    		}
    		~Base1(){
    			cout<<"Base1 is destructed..."<<endl; 
    		}
    		void print() const{
    			cout<<b<<endl;
    		}
    	private:
    		int b;
    	
    };
    class Base2:public Base1{
    	public:
    		Base2(){
    			c=0;
    			cout<<"Base2 is constructed..."<<endl;
    		}
    		Base2(int i,int j):Base1(i),c(j){
    			cout<<"Base2 is constructed..."<<endl;
    		}
    		~Base2(){
    			cout<<"Base2 is destructed..."<<endl; 
    		}
    		void print() const{
    			Base1::print();
    			cout<<c<<endl;
    		}
    	private:
    		int c;
    	
    };
    int main(){
    	Base2 b(1,2);
    	b.print();
    	return 0;
    }
    

    继承时派生类将基类所需的初始化参数传递给基类进行初始化,然后初始化自己的列表。上述程序过程中,生成Base2的对象,由于有两个参数,因此调用有两个参数的构造函数Base2(int i,int j):Base1(i),c(j){},这个函数要向Base1的构造函数传递参数,因此先进行Base1的构造,运行结果如下:
    在这里插入图片描述
    由上述可知派生类构造函数的执行顺序:

    1.调用基类的构造函数,顺序按照它们被继承时声明的顺序,先声明先构造。
    2.对初始化列表中的成员进行初始化,顺序按照它们在类中定义的顺序,先定义先构造。
    对象成员初始化时自动调用其所属类的构造函数,由初始化列表提供参数。
    3.初始化派生类的构造函数体中的内容。

    以下程序进行构造顺序的知识点加强:

    #include<iostream>
    using namespace std;
    class Base1{
    	public:
    	Base1(int a){
    		cout<<"Base1 is constructed..."<<a<<endl; 
    	}
    }; 
    class Base2{
    	public:
    	Base2(int a){
    		
    		cout<<"Base2 is constructed..."<<a<<endl; 
    	}
    }; 
    class Base3{
    	public:
    	Base3(){
    		cout<<"Base3 is constructed..."<<endl; 
    	}
    }; 
    class Depre:public Base1,public Base2,public Base3{
    	public: 
    	Depre(int a,int b,int c,int d):Base1(a),Base2(b),number1(c),number2(d){}
    	private:
    		Base1 number1;
    		Base2 number2;
    		Base3 number3;
    };
    int main(){
    	Depre d(5,2,6,7);
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述

    派生类的析构函数

    析构函数也不能被继承,派生类如果需要,则需要自行声明析构函数,声明方式与无继承关系时的析构函数相同。(不用显示调用基类的析构函数,系统会自动隐式调用)
    析构的顺序与构造时正好相反。
    构造时先构造基类继承过来成员,再构造自身函数体的内容,而析构时先析构本类自己的成员,然后再析构继承过来的成员(析构自己的成员时最后被构造的最先析构,析构继承的成员时,最后继承的最先被析构)

    #include<iostream>
    using namespace std;
    class Base1{
    	public:
    	Base1(int a){
    		cout<<"Base1 is constructed..."<<a<<endl; 
    	}
    	~Base1(){
    		cout<<"Base1 is destructed..."<<endl; 
    	} 
    }; 
    class Base2{
    	public:
    	Base2(int a){
    		
    		cout<<"Base2 is constructed..."<<a<<endl; 
    	}
    	~Base2(){
    		cout<<"Base2 is destructed..."<<endl; 
    	} 
    }; 
    class Base3{
    	public:
    	Base3(){
    		cout<<"Base3 is constructed..."<<endl; 
    	}
    	~Base3(){
    		cout<<"Base3 is destructed..."<<endl; 
    	} 
    }; 
    class Depre:public Base1,public Base2,public Base3{
    	public: 
    	Depre(int a,int b,int c,int d):Base1(a),Base2(b),number1(c),number2(d){}
    	private:
    		Base1 number1;
    		Base2 number2;
    		Base3 number3;
    };
    int main(){
    	Depre d(5,2,6,7);
    	return 0;
    }
    

    运行结果如下:
    在这里插入图片描述
    如上所示,先析构了自己本类的成员,最后构造的最先析构,按number3,number2,number1的顺序,再析构继承过来的成员,最后继承的最先析构,按Base3,Base2,Base1的顺序。

    派生类的访问

    当派生类中与基类有相同成员时:

    若未特别限定,则通过派生类对象使用的是派生类中的同名成员(同名隐藏规则),即默认访问多个同名函数中所属派生类的那个。若要通过派生类对象访问基类中被隐藏的同名函数,可以使用基类名加作用域操作符::来限定。比如以下 d.Base1::fun();,实现调用基类被隐藏的fun()函数。

    #include<iostream>
    using namespace std;
    class Base1{
    	public:
    	int var;
    	void fun(){
    		cout<<"number of Base1"<<endl;
    	} 
    };
    class Base2{
    	public:
    	int var;
    	void fun(){
    		cout<<"number of Base2"<<endl;
    	} 
    };
    class Derived:public Base1,public Base2{
    	public:
    		int var;
    		void fun(){
    			cout<<"number of Derived"<<endl;
    		}
    }; 
    int main(){
    	Derived d;
    	d.fun();//同名隐藏原则,默认调用派生类的同名函数
    	d.Base1::fun();
    }
    

    运行结果如下:
    在这里插入图片描述

    当派生类中无与基类有相同成员时:

    同时从不同基类继承了同名成员时访问成员存在二义性问题,即继承之后,这些同名函数如何区分,如何访问成了问题。(可以采用用类名限定来解决二义性的问题)

    class A{
    	public:
    	void q();
    };
    class B{
    	public:
    	void q();
    	void w();
    };
    class C:public A,public B{
    	public:
    	void w();
    	void e();
    };
    

    如果此时定义一个C c;,那么c.q();就存在二义性问题,而c.w()则无二义性(同名隐藏原则)。

    编写程序的时候应该要避免出现二义性和冗余问题(同时多次继承同一个类出现数据重复等等诸类情况)。

    展开全文
  • CStatic派生

    2019-08-26 11:18:55
    CStatic控件派生类,实现背景颜色,字体颜色、内容、对齐、粗细、斜体、大小、下划线等,链接,字体闪烁,控件边框设置
  • 几何体派生

    2018-09-10 12:39:57
    实现几何体派生,大学生个人项目。 东南大学大一个人项目
  • 派生:Rust的一组替代“派生”属性
  • 继承和派生复习

    2021-01-20 22:06:48
    继承和派生练习关于保护继承下列说法错误的是保护继承的特点是基类的所有公用成员和保护成员都成为派生类的保护成员派生类对象不能访问基类中的任何成员派生类的对象可以访问基类的公有成员保护继承的派生类和私有继
  • 继承与派生总结

    2018-06-19 18:07:34
    c++继承与派生总结 面向对象的程序设计中提供了类的继承机制,允许程序员在保持原有类特性的基础上,进行更具体、更详细的类的定义。以原有的类为基础产生新的类,我们就说新类继承了原有类的特征,也就是说从原有类...
  • c++派生

    2018-01-15 15:42:29
    class 派生类名:[继承方式] 基类名{派生类新增加的成员}; 继承方式包括: public (公用的),private (私有的)和protected(受保护的),此项是可选的,如果不写此项,则默认为private(私有的)。 此外,在声明派生...

    转载自


    声明派生类的一般形式为
    class 派生类名:[继承方式] 基类名{派生类新增加的成员};
    继承方式包括: public (公用的),private (私有的)和protected(受保护的),此项是可选的,如果不写此项,则默认为private(私有的)。

    此外,在声明派生类时,一般还应当自己定义派生类的构造函数和析构函数,因为构造函数和析构函数是不能从基类继承的。派生类是基类定义的延续。

    在派生类中,对基类的继承方式可以有public(公用的),private (私有的)和protected(保护的)3种。不同的继承方式决定了基类成员在派生类中的访问属性。简单地说:

    公用继承(public inheritance)
    基类的公用成员和保护成员在派生类中保持原有访问属性,其私有成员仍为基类私有。
    私有继承(private inheritance)
    基类的公用成员和保护成员在派生类中成了私有成员,其私有成员仍为基类私有。
    受保护的继承(protected inheritance)
    基类的公用成员和保护成员在派生类中成了保护成员,其私有成员仍为基类私有。保护成员的意思是: 不能被外界引用,但可以被派生类的成员引用,

    采用公用继承方式时,基类的公用成员和保护成员在派生类中仍然保持其公用成员和保护成员的属性,而基类的私有成员在派生类中并没有成为派生类的私有成员,它仍然是基类的私有成员,只有基类的成员函数可以引用它,而不能被派生类的成员函数引用,因此就成为派生类中的不可访问的成员。

    由于基类的私有成员对派生类来说是不可访问的,因此在派生类中的函数中直接引用基类的私有数据成员是不允许的。只能通过基类的公用成员函数来引用基类的私有数据成员。

    私有基类的公用成员和保护成员在派生类中的访问属性相当于派生类中的私有成员,即派生类的成员函数能访问它们,而在派生类外不能访问它们。私有基类的私有成员在派生类中成为不可访问的成员,只有基类的成员函数可以引用它们。一个基类成员在基类中的访问属性和在派生类中的访问属性可能是不同的。

    大家需要记住: 既然声明为私有继承,就表示将原来能被外界引用的成员隐藏起来,不让外界引用,因此私有基类的公用成员和保护成员理所当然地成为派生类中的私有成员。

    私有基类的私有成员按规定只能被基类的成员函数引用,在基类外当然不能访问他们,因此它们在派生类中是隐蔽的,不可访问的。对于不需要再往下继承的类的功能可以用私有继承方式把它隐蔽起来,这样,下一层的派生类无法访问它的任何成员。可以知道: 一个成员在不同的派生层次中的访问属性可能是不同的。它与继承方式有关。

    应当注意到: 虽然在派生类外不能通过派生类对象调用私有基类的公用成员函数,但可以通过派生类的成员函数调用私有基类的公用成员函数(此时它是派生类中的私有成员函数,可以被派生类的任何成员函数调用)。

    如果基类声明了私有成员,那么任何派生类都是不能访问它们的,若希望在派生类中能访问它们,应当把它们声明为保护成员。如果在一个类中声明了保护成员,就意味着该类可能要用作基类,在它的派生类中会访问这些成员。

    在定义一个派生类时将基类的继承方式指定为protected的,称为保护继承,用保护继承方式建立的派生类称为保护派生类(protected derived class ), 其基类称为受保护的基类(protected base class ),简称保护基类。

    保护继承的特点是: 保护基类的公用成员和保护成员在派生类中都成了保护成员,其私有成员仍为基类私有。也就是把基类原有的公用成员也保护起来,不让类外任意访问。

    保护基类的所有成员在派生类中都被保护起来,类外不能访问,其公用成员和保护成员可以被其派生类的成员函数访问。

    比较一下私有继承和保护继承(也就是比较在私有派生类中和在保护派生类中的访问属性), 可以发现,在直接派生类中,以上两种继承方式的作用实际上是相同的: 在类外不能访问任何成员,而在派生类中可以通过成员函数访问基类中的公用成员和保护成员。但是如果继续派生,在新的派生类中,两种继承方式的作用就不同了。

    例如,如果以公用继承方式派生出一个新派生类,原来私有基类中的成员在新派生类中都成为不可访问的成员,无论在派生类内或外都不能访问,而原来保护基类中的公用成员和保护成员在新派生类中为保护成员,可以被新派生类的成员函数访问。

    大家需要记住:基类的私有成员被派生类继承后变为不可访问的成员,派生类中的一切成员均无法访问它们。如果需要在派生类中引用基类的某些成员,应当将基类的这些成员声明为protected,而不要声明为private。

    如果善于利用保护成员,可以在类的层次结构中找到数据共享与成员隐蔽之间的结合点。既可实现某些成员的隐蔽,又可方便地继承,能实现代码重用与扩充。

    通过以上的介绍,可以知道:

    在派生类中,成员有4种不同的访问属性:
    ① 公用的,派生类内和派生类外都可以访问。
    ② 受保护的,派生类内可以访问,派生类外不能访问,其下一层的派生类可以访问。
    ③ 私有的,派生类内可以访问,派生类外不能访问。
    ④ 不可访问的,派生类内和派生类外都不能访问。
    需要说明的是:
    ① 这里所列出的成员的访问属性是指在派生类中所获得的访问属性。
    ② 所谓在派生类外部,是指在建立派生类对象的模块中,在派生类范围之外。
    ③ 如果本派生类继续派生,则在不同的继承方式下,成员所获得的访问属性是不同的,在本表中只列出在下一层公用派生类中的情况,如果是私有继承或保护继承,

    定义派生类构造函数的一般形式为
    派生类构造函数名(总参数表列):基类构造函数名(参数表列),其他的成员对象名(参数表列,逗号分隔)

    {

    派生类中新增数成员据成员初始化语句

    }

    其他的成员对象名(参数表列) 注意这里是对象变量名称,不是某个具体的类了
    执行派生类构造函数的顺序是:

    调用基类构造函数,对基类数据成员初始化;
    调用子对象构造函数,对子对象数据成员初始化;
    再执行派生类构造函数本身,对派生类数据成员初始化。

    派生类构造函数的总参数表列中的参数,应当包括基类构造函数和子对象的参数表列中的参数。基类构造函数和子对象的次序可以是任意的,如上面的派生类构造函数首部可以写成

    编译系统是根据相同的参数名(而不是根据参数的顺序)来确立它们的传递关系的。但是习惯上一般先写基类构造函数。如果有多个子对象,派生类构造函数的写法依此类推,应列出每一个子对象名及其参数表列。

    在使用派生类构造函数时,有以下特殊的形式:

    当不需要对派生类新增的成员进行任何初始化操作时,派生类构造函数的函数体可以为空,即构造函数是空函数
    此派生类构造函数的作用只是为了将参数传递给基类构造函数和子对象,并在执行派生类构造函数时调用基类构造函数和子对象构造函数。在实际工作中常见这种用法。

    如果在基类中没有定义构造函数,或定义了没有参数的构造函数,那么在定义派生类构造函数时可不写基类构造函数。因为此时派生类构造函数没有向基类构造函数传递参数的任务。调用派生类构造函数时系统会自动首先调用基类的默认构造函数。

    如果在基类和子对象类型的声明中都没有定义带参数的构造函数,而且也不需对派生类自己的数据成员初始化,则可以不必显式地定义派生类构造函数。因为此时派生类构造函数既没有向基类构造函数和子对象构造函数传递参数的任务,也没有对派生类数据成员初始化的任务。

    在建立派生类对象时,系统会自动调用系统提供的派生类的默认构造函数,并在执行派生类默认构造函数的过程中,调用基类的默认构造函数和子对象类型默认构造函数。

    如果在基类或子对象类型的声明中定义了带参数的构造函数,那么就必须显式地定义派生类构造函数,并在派生类构造函数中写出基类或子对象类型的构造函数及其参数表。

    如果在基类中既定义无参的构造函数,又定义了有参的构造函数(构造函数重载),则在定义派生类构造函数时,既可以包含基类构造函数及其参数,也可以不包含基类构造函数。

    在调用派生类构造函数时,根据构造函数的内容决定调用基类的有参的构造函数还是无参的构造函数。编程者可以根据派生类的需要决定采用哪一种方式。

    在派生时,派生类是不能继承基类的析构函数的,也需要通过派生类的析构函数去调用基类的析构函数。

    在派生类中可以根据需要定义自己的析构函数,用来对派生类中所增加的成员进行清理工作。

    基类的清理工作仍然由基类的析构函数负责。

    在执行派生类的析构函数时,系统会自动调用基类的析构函数和子对象的析构函数,对基类和子对象进行清理。

    调用的顺序与构造函数正好相反:先执行派生类自己的析构函数,对派生类新增加的成员进行清理,然后调用子对象的析构函数,对子对象进行清理,最后调用基类的析构函数,对基类进行清理。

    展开全文
  • 继承与派生这是第四讲类的继承与派生继承与派生继承与派生很详细
  • 派生类的数据成员由所有基类的数据成员与派生类新增的数据成员共同组成,如果派生类新增成员中包括其他类的对象(子对象),派生类的数据成员中实际上还间接包括了这些对象的数据成员。
  • 1、单继承:class 派生类名:访问方式 基类名{ 派生类成员} 说明: 1.派生类名由用户自己命名 2.访问方式:公有、私有、保护 3.基类名必须是程序一个已有的类 4.冒号:告诉系统,派生类从那个基类派生 5.派生类...
  • c++的派生.pdf

    2021-08-27 11:15:49
    c++的派生.pdf
  • CHeaderCtrl与CListCtrl派生
  • C++继承与派生

    2021-01-20 03:38:21
    一、继承时,派生类包含基类除构造函数和析构函数之外的所有成员,构造函数和析构函数不能被继承;  覆盖:派生类中定义一个与基类数据成员或成员函数同名的成员,则替换基类的成员。  覆盖不是成员的重载,只是...
  • 继承与派生

    2014-04-15 13:12:32
    .掌握继承和派生的定义,派生类的定义方法。 (1)掌握继承的两种类型:单继承和多继承。 (2)掌握private,public,protected三种继承方式的特点
  • 1,继承和派生 CPeople.cpp代码如下 #include "pch.h" #include "CPeople.h" #include <iostream> using namespace std; CPeople::CPeople(char* name, char* sex, float height) { strcpy_s(this-&...

    1,继承和派生

    CPeople.cpp代码如下

    #include "pch.h"
    #include "CPeople.h"
    #include <iostream>
    using namespace std;
    
    
    CPeople::CPeople(char* name, char* sex, float height)
    {
    	strcpy_s(this->name, name);
    	strcpy_s(this->sex, sex);
    	this->height = height;
    }
    
    CPeople::~CPeople()
    {
    }
    void CPeople::showInfo()
    {
    	cout << "姓名:" << name << ",性别:" << sex << "身高:" << height ;
    }

    CPeople.h代码如下

    #pragma once
    class CPeople
    {
    public:
    	CPeople(char* name,char*sex,float height);
    	~CPeople();
    private:
    	char name[10];
    	char sex[10];
    	float height;
    public:
    	void showInfo();
    };
    

    MyStudents.cpp代码如下

    #include "pch.h"
    #include <iostream>
    #include "CStudent.h"
    
    int main(int argc, char* argv[])
    {
    	CStudent stu((char*)"li", (char*)"female",(float) 172, (char*)"a001");
    	stu.showAll();
    	return 0;
    }

    CStudent.cpp代码如下

    #include "pch.h"
    #include "CStudent.h"
    #include <iostream>
    using namespace std;
    
    
    CStudent::CStudent(char* name, char* sex, float height, char* no):CPeople(name, sex, height)//CPeople基函数初始化
    {
    	strcpy_s(this->no, no);
    }
    
    CStudent::~CStudent()
    {
    }
    void CStudent::showAll()
    {
    	showInfo();
    	cout << ",学号:" << no << endl;
    }

    CStudent.h代码如下

    #pragma once
    #include "CPeople.h"
    class CStudent :
    	public CPeople
    {
    public:
    	CStudent(char* name,char* sex,float height,char* no);
    	~CStudent();
    private:
    	char no[10];
    public:
    	void showAll();
    };
    

     2,公有派生类

    3,私有派生类 

    4,保护派生类 

     

    展开全文
  • MFC派生控件.rar

    2020-05-13 15:57:10
    MFC基础,自定义派生控件,举了4个例子,从4个方向详细介绍,源码比较简单,很容易看懂,举一反三,由浅入深。
  • C++通过类派生(class derivation)机制来支持继承。 被继承的类型称为基类(base class)或超类(superclass),新产生的类为派生类(derived class)或子类(subclass)。基类和派生类的集合称作类继承层次结构...

    层次概念是计算机的重要概念。通过继承(inheritance)的机制可对(class)分层,提供类型/子类型的关系。C++通过类派生(class derivation)机制来支持继承。

    被继承的类型称为基类(base class)或超类(superclass),新产生的类为派生类(derived class)或子类(subclass)。基类和派生类的集合称作类继承层次结构(hierarchy)。如果基类和派生类共享相同的公有接口,则派生类被称作类的子类型(subtype)。

    继承机制体现了现实世界的层次结构,如下图所示。

    派生反映了事物之间的联系,事物的共性与个性之间的关系。从工作量上看,工作量少,派生类中重复的部分可以从基类继承来,不需要再单独编程。

    “层次”的获得:多种考虑,例如类的分解问题(如何把多个类的共同特征分解到一个基类中)。

    类的派生与继承

    1、由基类派生出派生类的语法形式
    C++中由基类派生出派生类的语法形式为:
        class 派生类名:访问限定符 基类名1《,访问限定符 基类名2,……,访问限定符 基类名n 》
        {
            《 《private: 》成员表1;》
            //派生类增加或替代的私有成员
            《public: 成员表2;》
            //派生类增加或替代的公有成员
            《protected: 成员表3;》
            //派生类增加或替代的保护成员
        };//分号不可少

    其中,基类1,基类2,……是已声明的类。

    在派生类定义的类体中给出的成员称为派生类成员,它们是新增加的数据和函数成员。这些新增加的成员是派生类对基类的发展,它们给派生类添加了不同于基类的新的属性和功能。派生类成员包括新添加的,也包括通过屏蔽作用,取代基类成员的更新成员。

    2、单一继承和多重继承

    • 单一继承(single-inheritance) :一个派生类只有一个直接基类。
    • 多重继承(multiple-inheritance) :一个派生类可以同时有多个基类。

      派生类吸收了基类的几乎所有成员。

    3、编制派生类的步骤

    编制派生类时可分四步:

    1. 吸收基类的成员:不论是数据成员,还是函数成员,除构造函数与析构函数外全盘接收(继承方式)。
    2. 改造基类成员:声明一个和某基类成员同名的新成员,该新成员将屏蔽基类同名成员。称为同名覆盖(override)
    3. 发展新成员:派生类新成员必须与基类成员不同名,它的加入保证派生类在功能上有所发展。
    4. 重写构造函数与析构函数。

    说明:

    • 第2步中,新成员若是成员函数,参数表也必须一样,否则是重载。
    • 第3步中,独有的新成员才是继承与派生的核心特征。
    • 第4步是重写构造函数与析构函数,派生类不继承这两种函数。
    • 例如,在顺序表中,要求把数组改为动态建立,采用派生类的方法,在第二步用动态数组把静态数组覆盖掉;原来的构造函数与析构函数完全不能用了,新的函数要进行动态(堆)内存的分配与释放。
    • 不管原来的函数是否可用一律重写可免出错。

    注意:必须规范化地编程,除了算法必须规范化外,编程的步骤也必须规范化,上面的步骤就是继承与派生编程的规范化步骤。

    公有派生与私有派生

    派生类定义时的访问限定符,是指访问控制,亦称为继承方式,用于在派生类中对基类成员进一步的限制。

    访问控制也是三种:公有(public)方式保护(protected)方式私有(private)方式,相应的继承亦称公有继承保护继承私有继承。访问限定有两方面含义:

    1. 派生类新增成员函数对基类(继承来的)成员的访问;
    2. 从派生类对象之外对派生类对象中的基类成员的访问。

    下表给出公有派生和私有派生的访问限制。

    公有派生是绝对主流。

    展开全文
  • C++ 类的继承与派生实例详解 继承性是面向对象程序设计最重要的特性之一,使软件有了可重用性,C++提供的类的继承机制。 继承与派生的概念 一个新类从已有的类那里获得已有的特性,这种现象称为类的继承。同样也可以...
  • 只有公用派生类才是基类真正的子类型,它完整地继承了基类的功能。基类与派生类对象之间有赋值兼容关系,由于派生类中包含从基类继承的成员,因此可以将派生类的值赋给基类对象,在用到基类对象的时候可以用其子类...
  • C语言 继承与派生.ppt

    2020-10-30 08:57:53
    第7章 继承与派生 7.1 继承与派生 7.2 多继承 7.3 类的继承方式 7.4 派生类的构造和析构函数 7.5 派生中成员的标识与访问 7.6 虚基类 7. 7 类模板的派生和继承 7.1 继承与派生 7.1.1 继承与派生的概念 举个简单的...
  • MFC 派生控件的陷阱

    2016-12-27 10:49:41
    MFC 派生控件的陷阱
  • 区分“派生类对象”和“派生类”对基类成员的访问权限 文字部分来源:https://blog.csdn.net/weixin_34283445/article/details/90683769 区分“派生类对象”和“派生类”对基类成员的访问权限。  “派生类对象...
  • pfcg派生权限

    2015-03-26 17:08:32
    PFCG派生
  • 通过分析完善我国股东派生诉讼制度对优化我国公司治理结构、抑制公司董事等高层的恣意及中小股东利益保护的必要性,提出了扩大股东派生诉讼原告的范围、简化股东派生诉讼的前置程序及合理收取诉讼费用等相关措施,以...
  • 4、继承和派生.mmap

    2021-02-01 10:58:16
    继承与派生知识大纲(使用Mindjet MindManager打开)
  • c#派生

    2020-04-20 21:27:02
    派生类声明 [类修饰符] class 派生类 :基类 派生类除了构造函数和析构函数,派生类继承了 基类的所有成员 class Program { static void Main(string[] args) { B bb = new B(); bb.afun(); } clas...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 405,187
精华内容 162,074
关键字:

派生