精华内容
下载资源
问答
  • 第十章 C#继承 派生类 派生类的构造方法.docx
  • 所谓隐藏是指使用常规的调用方法,派生类对象访问这个函数时,会优先访问派生类中的这个函数,基类中的这个函数对派生类对象来说是隐藏起来的。 但是隐藏并不意味这不存在或完全不可访问。通过 b->Base::func()访问...
  • 派生类的数据成员由所有基类的数据成员与派生类新增的数据成员共同组成,如果派生类新增成员中包括其他类的对象(子对象),派生类的数据成员中实际上还间接包括了这些对象的数据成员。
  • protected 与 public 和 private 一样是用来声明成员的访问权限的。由protected声明的成员...在定义一个派生类时将基类的继承方式指定为protected的,称为保护继承,用保护继承方式建立的派生类称为保护派生类(protec
  • CStatic派生类

    2019-08-26 11:18:55
    CStatic控件派生类,实现背景颜色,字体颜色、内容、对齐、粗细、斜体、大小、下划线等,链接,字体闪烁,控件边框设置
  • 主要介绍了C++中基类和派生类之间的转换,有助于深入理解C++面向对象程序设计,需要的朋友可以参考下
  • 派生类

    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()则无二义性(同名隐藏原则)。

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

    展开全文
  • 基类对象与派生类对象的使用关系 派生类对象作为基类对象处理 由于派生类具有所有基类的成员所以把派生类的对赋给基类对象是合理的不过要求这种继承方式必须是public方式但是反过来赋值会使基类中一具有派生类的成员...
  • 基类与派生类对象之间有赋值兼容关系,由于派生类中包含从基类继承的成员,具体表现在以下几个方面,需要的朋友可以参考下
  • 派生类的构造与析构派生类的构造派生类的构造与派生类的构造与析构析构与析构派生类的构造与析构
  • 主要介绍了C++编程中派生类的析构函数,析构函数平时一般使用较少,需要的朋友可以参考下
  • 主要介绍了详解C++中基类与派生类的转换以及虚基类,是C++入门学习中的基础知识,需要的朋友可以参考下
  • 主要介绍了结合.net框架在C#派生类中触发基类事件及实现接口事件,示例的事件编程中包括接口和类的继承等面向对象的基础知识,需要的朋友可以参考下
  • 以此雇员为基类,从中派生出教师,其中要求在教师中加入一个计算教师工资的方法,教师工资=基本工资(1000)+课时(月工作量)×30。以此雇员为基类,从中派生出实验员,其中要求在实验员中加入一个计算...
  • C++派生类的构成 派生类中的成员包括从基类继承过来的成员和自己增加的成员两大部分。从基类继承的成员体现了派生类从基类继承而获得的共性,而新增加的成员体现了派生类的个性。正是这些新增加的成员体现了派生类与...
  • 派生类的定义

    2021-03-22 21:18:01
    基类与派生类 继承(inheritance)是面对对象程序设计的一个重要特性,是软件复用(software reuse)的一个重要形式。 继承允许在原有类的基础上创建新的类,新类可以从一个或多个原有类中继承数据成员和成员函数,...

    类的继承与派生

    基类与派生类

    继承(inheritance)是面对对象程序设计的一个重要特性,是软件复用(software reuse)的一个重要形式。

    继承允许在原有类的基础上创建新的类,新类可以从一个或多个原有类中继承数据成员和成员函数,并且可以重新定义或增加新的成员,从而形成类的层次。继承具有传递性,不仅支持系统的可重用性,而且还促进系统的可扩充性。

    类的对象是各自封闭的,如果没继承性机制,则类对象中数据,函数就会出现大量重复

    继承改变了传统程序设计对不再使用的数据类型和函数进行改写甚至重写的方法,克服了程序无法重复使用的缺点。

    通过继承,可吸收现有类的数据和函数来创建新类,并增添新的成员增强此类,这样可以节约程序开发的时间。

    在C++中,继承就是在一个已存在的类的基础上建立一个新的类。已存在的类称为基类(base class),又称为父类;新建立的类称为派生类(dervied class),又称为子类

    一个新类从已有的类那里获得其特性,这种现象称为类的继承

    另一方面,从已有的父类产生一个新的子类,称为类的派生。派生类继承了基类的所有数据成员和成员函数,具有基类的特性,派生类还可以对成员作必要的增加或调整,定义自己的新特性。

    一个基类可以派生出多个派生类,每一个派生类又可以作为基类再派生出新的派生类,因此基类和派生类是相对而言的。

    派生类分为单级派生多级派生

    在这里插入图片描述
    一个派生类可以只从一个基类派生,称为单一继承(single inheritance),这是最常见的继承形式,如图所示,类B和类C都只从类A派生
    在这里插入图片描述
    一个派生类有两个及两个以上的基类,称为多重继承(multiple inheritance),如图所示,类C从类A和类B派生。
    在这里插入图片描述
    基类与派生类之间的关系为:

    (1)基类是对派生类的抽象,派生类是对基类的具体化。基类抽取了它与派生类的公共特征,而派生类通过增加信息将抽象的基类变为某种具体的类型。

    (2)派生类是基类的组合,可以把多重继承看作是多个单一继承的简单组合。

    派生类的定义

    定义派生类的一般形式为:

    class 派生类名 : 类派生列表 { //类体
    	成员列表
    };
    

    除了增加类派生列表外,派生类的定义与类定义并无区别。

    类派生列表(class derivation list)指定了一个或多个基类(base class),具有如下形式:

    访问标号 基类名
    

    类派生列表可以指定多个基类,中间用逗号(,)间隔,基类名必须是已定义的类名字。

    访问标号表示继承方式,可以是public(公有继承),protected(保护继承)或private(私有继承),继承方式决定了对继承成员的访问权限。如果未给出访问标号则默认为private(私有继承)。

    派生类的成员列表描述的是派生类自己新增加的数据成员和成员函数。

    派生类举例:

    #include<iostream>
    using namespace std;
    
    class Base { //基类
    	private:
    		int b_number;
    	public:
    		Base() { } //基类不带参数的构造函数
    		Base(int i) : b_number(i) { } //基类带参数的构造函数
    		int get_number() { return b_number; }
    		void print() { cout<<b_number<<endl; }
    };
    
    class Derived : public Base { //派生类
    	private:
    		int d_number; //派生类增加的数据成员
    	public:
    		Derived(int i,int j) : Base(i),d_number(j) { } //派生类构造函数
    		void print() { //派生类增加的成员函数
    			cout<<get_number()<<" "; //派生类继承的成员函数
    			cout<<d_number<<endl;
    		}
    };
    
    int main()
    {
    	Base a(2);
    	Derived b(3,4);
    	cout<<"a is ";
    	a.print(); //基类的print
    	cout<<"b is ";
    	b.print(); //派生类的print
    	cout<<"base part of b is ";
    	b.Base::print(); //基类的print
    	return 0;
    }
    

    派生类的构成

    派生类的说明:

    (1)用作基类的类必须是已定义的,其原因是显而易见的:每个派生类包含并且可以访问其基类的成员,为了使用这些成员,派生类必须知道它们是什么。这一规则说明不可能从类自身派生出一个类

    (2)如果需要声明(但并不实现)一个派生类,则只需要声明类名即可。

    (3)显然,在一个派生类中,其成员由两部分构成:一部分是从基类继承得到的,另一部分是自己定义的新成员,所有这些成员仍然分为public(公有),private(私有)和protected(保护)三种访问属性。

    (4)友元关系不能继承。一方面,基类的友元对派生类的成员没有特殊访问权限。另一方面,如果基类被授予友元关系,则只有基类具有特殊访问权限,该基类的派生类不能访问授予友元关系的类。

    (5)如果基类定义了静态成员,则整个继承层次中只有一个这样的成员。无论从基类派生出多少个派生类,每个静态成员只有一个实例

    (6)静态成员遵循常规访问控制:如果静态成员在基类中为私有的,则派生类不能访问它。如果该静态成员在基类是公有的,则基类可以访问它,派生类也可以访问它。

    (7)一般地,可以使用作用域运算符(::)也可以使用对象成员引用运算符(.)或指针成员引用运算符(->)访问静态成员。

    在这里插入图片描述
    在实际的编程中,设计一个派生类包括4个方面的工作:
    (1)从基类接收成员
    除了构造函数和析构函数,派生类会把基类全部的成员继承过来。这种继承是没有选择的,不能选择接收其中一部分成员,而舍弃另一部分成员

    (2)调整基类成员的访问
    派生类接收基类成员是程序员不能选择的,但是程序员可以对这些成员作出访问策略

    (3)修改基类成员
    可以在派生类中声明一个与基类成员同名的成员,则派生类中的新成员会覆盖基类的同名成员,就实现了修改基类成员功能的效果

    (4)在定义派生类时增加新的成员
    一般还应当自己定义派生类的构造函数和析构函数

    #include<iostream>
    using namespace std;
    
    class Base { //基类
    	private:
    		int b_number;
    	public:
    		Base( ){} //基类不带参数的构造函数
    		Base(int i) : b_number (i) { } //基类带参数的构造函数
    		int get_number( ) {return b_number;}
    		void print( ) {cout << b_number << endl;}
    };
    
    class Derived : public Base { //派生类
    	private:
    		int d_number; //派生类增加的数据成员
    	public:
    		Derived(int i,int j):Base(i),d_number(j){ };
    		//派生类构造函数
    		void print() { //派生类增加的成员函数
    			cout << get_number() << " "; //派生类继承的成员函数
    			cout << d_number << endl;
    		}
    };
    
    int main()
    {
    	Base a(2);
    	Derived b(3,4);
    	cout<<"a is ";
    	a.print();
    	cout<<"b is ";
    	b.print();
    	return 0;
    }
    
    展开全文
  • 本文实例讲述了C#接口在派生类和外部类中的调用方法。分享给大家供大家参考,具体如下: C#的接口通过interface关键字进行创建,在接口中可以包含属性,方法等成员变量。接口的派生类可以对接口中的方法进行实现。一...
  • 基类,派生类

    2012-04-02 21:35:51
    基类,派生类
  • 区分“派生类对象”和“派生类”对基类成员的访问权限 文字部分来源:https://blog.csdn.net/weixin_34283445/article/details/90683769 区分“派生类对象”和“派生类”对基类成员的访问权限。  “派生类对象...

    区分“派生类对象”和“派生类”对基类成员的访问权限
    文字部分来源:https://blog.csdn.net/weixin_34283445/article/details/90683769

     “派生类对象”对基类成员的访问权限:
    (1)对于公有继承,只有基类的公有成员可以被“派生类对象”访问,其他(保护和私有)成员不能被访问。
    (2)对于私有继承和保护继承,基类中所有成员都不能被“派生类对象”访问。
     “派生类”对基类中成员的访问权限:
    (1)对于公有继承,基类中的公有成员和保护成员可以被“派生类”访问,而基类中的私有成员不能被访问。
    (2)对私有继承和保护继承,也是基类中的公有成员和保护成员可以被“派生类”访问,而基类中的私有成员不能被访问。
    另附一张图片助于理解

    三种继承和三种声明

    展开全文
  • c++派生类例子

    2014-06-07 20:51:13
    派生类例子输入几个几何图形的体积在主函数用指向数组的指针输出
  • C++派生类

    2020-11-24 20:33:51
    C++派生类派生类的概念 派生类的概念 类之间有一种层次关系,有父亲类,孩子类。 父类(基类,超类)派生出来子类(派生类)。 继承:有父亲类,有孩子类,就构成了层次关系。继承是面向对象程序设计的核心思想之一...

    C++派生类

    派生类的概念

    类之间有一种层次关系,有父亲类,孩子类。
    父类(基类,超类)派生出来子类(派生类)。
    继承:有父亲类,有孩子类,就构成了层次关系。继承是面向对象程序设计的核心思想之一。
    这种继承,要先定义一个父类。父类中定义一些公用的成员变量,成员函数。通过继承父类构建新的类:子类。所以写代码是,只需要写和子类相关的东西即可。子类一般会比父类更加庞大。

    定义一个Human类:

    #pragma once
    #ifndef __HUMAN__
    #define __HUMAN__
    #include <iostream>
    class Human {
    	Human();
    	Human(int);
    public:
    	int m_Age;
    	char m_Name;
    
    };//类结尾一定要分号
    
    #endif // !__HUMAN__
    

    定义一个Humen的子类Men:

    #pragma once
    #ifndef __MAN__
    #define __MAN__
    #include <iostream>
    #include "Human.h"
    //成为Human的子类
    class Man : public Human //表示Men是Humen的子类
    {
    	Man();
    public:
    
    };//类结尾一定要分号
    
    #endif // !__HUMAN__
    

    class Men:public Human:表示Men是Humen的子类。
    class 子类名:继承方式 父类名
    继承方式(访问权限):public ,private,protected。

    展开全文
  • 一个小的实例,实现类的派生,基类和派生类构造函数之间关系,自己学习时总结的例子,供大家参考批评与指正
  • VC MFC CEDIT派生类 控件背景色 字体修改 并能自动控制显示行数
  • 从类base派生两个类,每个派生类定义函数iam()输出派生类的名字。
  • C++ 继承性:派生类

    千次阅读 2018-05-17 00:05:47
    C++继承性:派生类 继承:继承是面向对象程序设计的一个重要机制,该机制自动地为一个类提供来自另一个类的操作和数据结构,这使程序员只需在新类中定义已有类中没有的成员来建立新类。即,它允许在既有类的基础...
  • 【C++】C++继承和派生类、虚基类

    万次阅读 多人点赞 2018-06-07 18:46:17
    派生则是继承的直接产物,它通过继承已有的一个或多个来产生一个新的,通过派生可以创建一种类族。 继承 基本概念 在定义一个A时,若它使用了一个已定义B的部分或全部成员,则称A继承了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 353,758
精华内容 141,503
关键字:

派生类的派生类