精华内容
下载资源
问答
  • 一个简单的基类

    2014-06-25 16:50:14
    一个类派生出另一个类时,原始称为基类

    从一个类派生出另一个类时,原始类称为基类,继承类称为派生类。

    class TableTennisPlayer
    {
    private:
    	enum{LIM=20};
    	char firstname[LIM];
    	char lastname[LIM];
    	bool hasTable;
    public:
    	TableTennisPlayer(const char * fn,const char *ln,bool ht);
    	void Name() const;
    	bool HasTable()const{return hasTable;};
    	void RestTable(bool v){hasTable=v};
    }
     将RatedPlayer类声明为从TableTennisClass类派生而来

    class RatedPlayer :public TableTennisPlayer
    {
    }
    冒号指出RatedPlayer 类的基类是TableTennisPlayer类。派生类对象包含基类对象。使用公有派生,基类的公有成员将成为派生类的公有成员;基类的私有部分也将称为派生类的一部分,但是只能通过基类的公有和保护方法访问。

    派生类需要自己的构造函数,派生类可以根据需要添加额外的数据成员和成员函数。

    class RatedPlayer :public TableTennisPlayer
    {
    private:
    	unsigned int rating;
    public:
    	RatedPlayer(unsigned int r=0,const char *fn="none",const char *ln="none",bool ht=false);
    	RatedPlayer(unsigned int r,const TableTennisPlayer & tp);
    	unsigned int Rating(){return rating};
    	void ResetRating(unsigned int r){rating r;};
    }

    派生类不能直接访问私有成员,而必须通过基类方法进行访问。创建派生类对象时,程序首先创建基类对象。从概念上说,这意味着基类对象应当在程序进入派生类构造函数之前被创建。C++使用成员初始化列表句法来完成这种工作。

    RatedPlayer::RatedPlayer(unsigned int r,const char *fn,const char *ln,bool ht):TableTennisPlayer(fn,ln,ht)
    基类的对象必须首先被创建,如果不调用基类构造函数,程序将使用默认的基类构造函数。

    如果愿意,也可以对派生类成员使用成员初始化列表句法

    RatedPlayer::RatedPlayer(unsigned int r,const char *fn,const char *ln,bool ht):TableTennisPlayer(tp),rating(r){}

    有关派生类构造函数的要点:基类对象首先被创建。

    释放对象的顺序与创建对象的顺序相反,即首先执行派生类的析构函数,然后自动调用基类的析构函数。

    类对象对基类方法的使用:

    TableTennisPlayer player1("Tara","Boomdea",false);
    RatedPlayer rplayer1(1140,"Mallory","duck",ture);
    rplayer1.Name();

    展开全文
  • 派生基类

    2019-06-18 14:40:31
    继承从已派生出新的,而派生继承了原有基类)的数据成员和方法。 派生不能直接访问基类的私有成员,必须通过基类方法进行访问。 因此,派生构造函数必须使用基类构造函数(通过成员初始化...

    OOP的主要目的之一是实现代码可重用。类继承从已有的类派生出新的类,而派生类继承了原有类(基类)的数据成员和方法。

    • 派生类不能直接访问基类的私有成员,必须通过基类方法进行访问。
      因此,派生类构造函数必须使用基类构造函数(通过成员初始化列表)。

    派生类访问基类私有数据

    派生类不能直接访问基类的私有数据,而必须使用基类的公有方法来访问这些数据。而构造函数和其他成员函数使用的技术不同:

    1. 构造函数:派生类构造函数在初始化基类私有数据时,采用的是成员初始化列表语法,将基类信息传递给基类构造函数,然后使用构造函数体初始化派生类新增的数据项。
    2. 非构造函数:非构造函数不能使用成员初始化列表语法,但派生类方法可以调用公有的基类方法,即使用作用域解析运算符来调用基类方法:
    void BrassPlus::View() const
    {
    ...
    	Brass::View();
    	cout<<...
    }
    

    派生类和基类之间的特殊关系

    1. 派生类对象可以使用基类的方法,条件是方法不是私有的。
    2. 基类指针可以在不进行显式类型转换的情况下指向派生类对象
    3. 基类引用可以在不进行显式类型转换的情况下引用派生类对象1
    4. 3、4的关系是单向的,不可以将基类对象和地址赋给派生类引用和指针。
    5. 然而,基类指针或引用只能用于调用基类方法,不能调用派生类方法。
    指针、引用兼容特性的更多说明
    • 上述基类引用可以在不进行显式类型转换的情况下引用派生类对象带来的引用兼容属性,使得能够将基类对象初始化为派生类对象
    Derived olaf1(100, "Olaf", true);	//先初始化一个派生类对象olaf1
    Base olaf2(olaf1);	//再通过olaf1对象初始化基类对象olaf2
    

    这是隐式地通过基类复制构造函数完成的:Base(const Base &);,形参是基类引用,因此它可以引用派生类

    • 同样,也可以将派生对象赋给基类对象
    Derived olaf1(100, "Olaf", true);
    Base olaf2;
    olaf2= olaf1;
    

    这里将调用隐式重载赋值运算符Base & operator(const Base &) const;,基类引用指向了派生类对象。


    1. 将父类指针指向子类指针的方式,即将子类转换为父类,称为向上强制转换,是自动进行的。相反的过程称为向下强制转换,如果不使用显式类型转换是不允许的。 ↩︎

    展开全文
  •  派生的对象只能访问基类的public成员。  protected(保护继承),private(私有继承)  派生中的成员可以访问基类的public成员和protected成员,但不能访问基类的private成员。  派生的对象不能访问基类的...

      派生类中的成员可以访问基类的public成员和protected成员,但不能访问基类的private成员。

      派生类的对象只能访问基类的public成员。

      protected(保护继承),private(私有继承)

      派生类中的成员可以访问基类的public成员和protected成员,但不能访问基类的private成员。

      派生类的对象不能访问基类的任何成员。

      example 1:

      #include

      class A

      {

      public:

      void fun1(int a) {cout<

      void fun2(int b) {cout<

      };

      class B:public A

      {

      public:

      void fun3() {cout<<"It is in class B."<

      };

      int main()

      {

      B b;

      A a;

      b.fun3(); //Y(正确)

      b.fun2(); //Y

      b.fun1(); //Y

      a.fun3(); //N(错误)

      a.fun2(); //Y

      a.fun1(); //Y

      }

      example2:

      #include

      class A

      {

      public:

      void f1();

      A() {i1 = 10; j1 = 11;}

      protected:

      int j1;

      private:

      int i1;

      };

      class B:public A

      {

      public:

      void f2();

      B() {i2 = 20; j2 = 21;}

      protected:

      int j2;

      private:

      int i2;

      };

    展开全文
  • )抽象基类

    2016-02-04 02:00:25
    抽象基类(abstract base ...当一个类有了纯虚函数之后,它就成为了一个抽象基类。 抽象基类的特点是,不能创造该的对象。   例如B和C一定的共同点,把这些共同点(数据成员和方法)抽象出来,创建一个

    抽象基类(abstract base class,简称ABC)。

     

    抽象基类的前提是,类方法里有 纯虚函数pure virtual function)。

    纯虚函数需要在函数声明的结尾处添加“=0”。

     

    当一个类有了纯虚函数之后,它就成为了一个抽象基类。

    抽象基类的特点是,不能创造该类的对象。

     

    例如B类和C类的有一定的共同点,把这些共同点(数据成员和方法)抽象出来,创建一个A类,而B类和C类都从A类派生出来。而A类有一个纯虚函数,因此A类就成为了一个抽象基类。

     

    对于纯虚函数而言,可以在实现中不定义该函数,也可以定义该函数。不过对于在不需要在基类中定义的函数(例如两个派生类定义都不同的)可以让其称为纯虚函数。

    但总之,用=0来指出这是一个纯虚函数,于是类就成为了一个抽象基类。

     

    使用抽象基类后,不能创造该基类的对象,但可以声明该基类的指针,然后用指针去指向派生类对象,用于管理派生类的对象。

     

    另外,抽象基类的派生类,有时候被称为具体类。这表示可以创建这些类型的对象。

     

     

    总之,ABC描述的是至少使用一个纯虚函数的接口,从ABC派生出的类将根据派生类的具体特征,使用常规虚函数来实现这种接口。

     

    如代码:

    //1.h 抽象基类和派生类声明
    #pragma once
    #include<iostream>
    #include<string>
    using std::string;
    
    class BaseBank
    {
    	string name;
    	long acctNum;
    	double balance;
    protected:
    	struct Formatting
    	{
    		std::ios_base::fmtflags flag;
    		std::streamsize pr;
    	};
    	const string& Name()const { return name; }
    	const long AcctNum()const { return acctNum; }
    	Formatting setFormat()const;
    	void Restore(Formatting &f)const;
    public:
    	BaseBank(string na = "no body", long id = -1, double ba = 0.0);
    	void SaveMoney(double mo);	//存钱
    	double Balance()const { return balance; }	//查询余额
    	virtual void Withdraw(double mo) = 0;	//取款,纯虚函数
    	virtual void ViewAcct()const = 0;	//查询,纯虚函数
    	virtual ~BaseBank() {};	//虚的析构函数
    };
    
    class Brass:public BaseBank
    {
    public:
    	Brass(string na = "no body", int id = -1, double mo = 0);	//创建账户
    	virtual void Withdraw(double mo);	//取款
    	virtual void ViewAcct()const;	//显示账户信息
    	virtual ~Brass() {};	//虚析构函数
    };
    
    class Brass_plus :public BaseBank
    {
    	double maxLoan;	//透支上限,loan是贷款的意思
    	double rate;	//透支贷款利率
    	double owesBank ;	//owes是欠,这个是欠银行多少钱(透支)
    public:
    	Brass_plus(string na = "no body", long id = -1, double mo = 0.0, double ma = 500, double ra = 0.1125);	//构造函数
    	Brass_plus(const Brass& br,double ov_M = 500, double ov_R = 0.11125);
    	void ResetLoan(double ov_M);	//设置透支上限
    	void ResetRate(double ov_R);	//设置透支利率
    	virtual void Withdraw(double mo);	//取款,透支保护
    	virtual void ViewAcct()const;	//显示账号信息,更多
    	void ResetOwes() { owesBank = 0; }	//设置欠款为0
    };
    //2.cpp 抽象基类和派生类的定义
    #include"1.h"
    using std::cout;
    using std::endl;
    using std::string;
    typedef std::ios_base::fmtflags format;
    typedef std::streamsize precis;	//这个不明白是什么意思
    format setFormat();
    void restore(format f, precis p);
    
    //BaseBank类,抽象基类
    BaseBank::BaseBank(string na, long id, double ba)
    {
    	name = na;
    	acctNum = id;
    	balance = ba;
    }
    void BaseBank::SaveMoney(double mo)
    {
    	if (mo < 0)
    		cout << "你不能存入小于0的金钱。" << endl;
    	else
    	{
    		balance += mo;
    		cout << "存款成功。" << endl;
    	}
    }
    void BaseBank::Withdraw(double mo)
    {
    	balance -= mo;
    }
    BaseBank::Formatting BaseBank::setFormat()const	//设置小数显示2位
    {
    	Formatting f;
    	f.flag = cout.setf(std::ios_base::fixed, std::ios_base::floatfield);	//设置为显示小数形式(这里是6位小数)
    	f.pr = cout.precision(2);	//cout.precision(2)表示从这行开始显示2位小数,
    								//且其值为6(推测是因为之前是显示6位小数),因此相当于streamsize f.pr=6;(意味着f.pr=6)
    	return f;	//返回结构对象
    }
    void BaseBank::Restore(Formatting &f)const	//函数作用是显示6位小数
    {
    	cout.setf(f.flag, std::ios_base::floatfield);
    	cout.precision(f.pr);	//由于f.pr=6,因此从这行开始,显示6位小数
    }
    
    //Brass类,抽象基类的派生类
    Brass::Brass(string na, int id, double mo):BaseBank(na,id,mo)	//构造函数
    {
    }
    void Brass::Withdraw(double mo)	//取款
    {
    	if (mo < 0)
    		cout << "你不能取出小于0的金钱。" << endl;
    	else if (mo>Balance())
    		cout << "余额不足。" << endl;
    	else
    		BaseBank::Withdraw(mo);		//表示使用基类的Withdraw方法
    		cout << "取款成功。" << endl;
    }
    void Brass::ViewAcct()const
    {
    	Formatting f = setFormat();
    	cout << "————账号信息显示(储蓄卡)————" << endl;
    	cout << "用户名:" << Name() << endl;
    	cout << "账  号:" << AcctNum() << endl;
    	cout << "余  额:" << Balance() << "元" << endl;
    	cout << "———————————————————" << endl;
    	Restore(f);
    }
    
    //Brass_plus类
    Brass_plus::Brass_plus(const Brass& br, double lo, double ra):BaseBank(br)	//构造函数,使用Brass类参数
    {
    	maxLoan = lo;
    	rate = ra;
    	owesBank = 0;
    }
    Brass_plus::Brass_plus(string na, long id, double mo, double lo, double ra):BaseBank(na,id,mo)	//构造函数,全参数
    {
    	maxLoan = lo;
    	rate = ra;
    	owesBank = 0;
    }
    void Brass_plus::ResetRate(double ra)	//设置透支利率
    {
    	Formatting f = setFormat();
    	if (ra < 0)
    		cout << "设置失败,不能设置为负数。" << endl;
    	else
    	{
    		rate = ra;
    		cout << "设置成功,新的利率为:" << rate * 100 << "%" << endl;
    	}
    	Restore(f);
    }
    void Brass_plus::ResetLoan(double ma)	//设置透支上限
    {
    	if (ma < 0)
    	{
    		cout << "设置失败,不能设置为负数。" << endl;
    	}
    	else
    	{
    		maxLoan = ma;
    		cout << "设置成功,新的透支上限为:" << maxLoan << "元" << endl;
    	}
    }
    
    void Brass_plus::ViewAcct()const	//显示账号信息,more
    {
    	Formatting f = setFormat();
    	cout << "————账号信息显示(储蓄卡)————" << endl;
    	cout << "用户名:" << Name() << endl;
    	cout << "账  号:" << AcctNum() << endl;
    	cout << "余  额:" << Balance() << "元" << endl;
    	cout << "账户透支上限:" << maxLoan << " 元" << endl;
    	cout << "透支偿还利率:" << rate * 100 << " %" << endl;
    	cout << "当前透支额度为:" << owesBank << " 元" << endl;
    	cout << "———————————————————" << endl;
    	Restore(f);
    }
    void Brass_plus::Withdraw(double mo)	//取款,带有透支保护
    {
    	Formatting f = setFormat();
    	double MO = Balance();
    	if (mo <MO)	//不涉及透支的取款
    	{
    		BaseBank::Withdraw(mo);
    	}
    	else if (mo>MO+maxLoan-owesBank)	//透支程度大于限额
    		cout << "超出限额,取款失败。" << endl;
    	else
    	{
    		owesBank += mo - MO;
    		BaseBank::Withdraw(MO);	//先取光余额
    		cout << "取款成功,余额为:" << MO << ",透支额为:" << owesBank << " 元,最大透支额为: " << maxLoan << "元" << endl;
    	}
    	Restore(f);
    }
    //1.cpp main函数测试用
    #include<iostream>
    #include"1.h"
    
    int main()
    {
    	using namespace std;
    	string name;
    	cout << "输入姓名:";
    	cin >> name;	//不能读取空格
    	cout << "输入ID编号(数字形式):";
    	int ID;
    	cin >> ID;
    	cout << "输入存款金额:";
    	double money;
    	cin >> money;
    	Brass one(name, ID, money);
    	cout << "银行账户创建完毕。" << endl;
    	Brass_plus two(one);
    	cout << "已建立信用账号:" << endl;
    	double a;
    	
    	cout << "s.存\tl.取.\tc.查询\tq.退出\n选择->";
    	char ch;
    	while (cin>>ch&&ch!='q')
    	{
    		cin.sync();
    		switch (ch)
    		{
    		case's':cout << "输入存款金额:";
    			cin >> a;
    			two.SaveMoney(a);
    			break;
    		case'l':cout << "输入取款金额:";
    			cin >> a;
    			two.Withdraw(a);
    			break;
    		case'c':two.ViewAcct();
    			break;
    		default:cout << "输入错误。" << endl;
    			cin.clear();
    			cin.sync();
    			break;
    		}
    		cout << "s.存\tl.取.\tc.查询\tq.退出\n选择->";
    	}
    	cout << "设置利率(%):";
    	double LiLv;
    	cin >> LiLv;
    	LiLv /= 100;
    	two.ResetRate(LiLv);
    	cout << "设置最大透支额度:";
    	double Max;
    	cin >> Max;
    	two.ResetLoan(Max);
    	cout << "再次查看账户信息:";
    	two.ViewAcct();
    	cout << "Done." << endl;
    	system("pause");
    	return 0;
    }
    

    总结:

    ①这个代码和之前的代码,主要是增添了抽象基类,更改了一些类定义,增添了protected保护方法。

     

    ②更改了显示的方法。 struct Formatting

    {

    std::ios_base::fmtflags flag;

    std::streamsize pr;

    };

     

    而显示方法的2个类型被放在保护成员(protected)范围内,因此,其派生类BrassBrass_plus都可以直接访问。

    注:以下两个都不是很明白。

    ios_base::fmtflag是 用于指定输出外观的常数。它作为类型时,可以存储输出格式,比如ios_base::fixed,ios_base::floatfield以及其他

    更多可见:https://msdn.microsoft.com/zh-cn/library/d2a1929w.aspx

    http://www.cplusplus.com/reference/ios/ios_base/fmtflags/

     

    streamsize表示流的大小(不懂),

    参见:http://www.cplusplus.com/reference/ios/streamsize/

     

    推测:代码:f.flag = cout.setf(std::ios_base::fixed, std::ios_base::floatfield);

    f.flag存储了std::ios_base::fixed这个指令。

    而cout.setf(f.flag, std::ios_base::floatfield); 就相当于用f.flag替代了std::ios_base::fixed 。

     

    另外,也可以这个结构Formatting和两个函数(setFormat()和Restore()放在名称空间之中,然后使用的时候使用其名称空间即可。例如放在Namespace qqq中,然后qqq::Formatting f=qqq::setFormat()这样。

     

    ③由于BrassBrass_plus都是根据基类BaseBank派生而来的,因此Brass_plus并不能使用Brass的类方法,只能使用抽象基类中二者公有的方法。

     

     

    ④当调用基类方法时,使用BaseBank::方法名 的形式,来使用。例如:BaseBank::Withdraw(mo)来调用方法,由于加了类名,因此是该类的方法。

     

    ⑤当使用指针时,应该使用BaseBank*作为指针类型。只有这样,才能同时指向两个派生类。

     

     

     

    ABC理念:

    在设计ABC(抽象基类)前,首先应开发一个模型——指出编程问题所需的类以及他们之间相互关系。

    一种学院派思路认为,如果要设计类继承层次,则只能将那些不会被用作基类的类设计为具体的类,这种方法的设计更清晰,复杂程度更低。——不懂

     

    可以将ABC类看做是一种必须实施的接口。ABC要求具体派生类覆盖其虚函数——迫使派生类遵循ABC设置的接口规则。这种模型在基于组件的编程模式中很常见,在这种情况下,使用ABC 使得组件设计人员能够制定“接口约定”,这样确保了从ABC派生的所有组件,都至少支持ABC指定的功能。

    上面这句话大概意思是:把抽象基类的几个功能,设置为纯虚函数,于是,如果要派生,那么必须在派生类里面具体化这些功能(于是这些功能必然有),否则派生类也有纯虚函数(因为没设计就没法覆盖)。

     

     

     


    展开全文
  • 派生基类的关系

    2020-12-18 13:47:27
    在C++中,我们允许 将派生对象赋给基类对象。(不允许将基类对象赋给派生对象) 只会将基类对象成员赋值,a1=b1;...原因很简单,派生一般含有基类没有的成员,将派生赋给基类成员我们才能保证基类中每
  • 只有公用继承能较好地保留基类的特征,它保留了除构造函数和析构函数以外的基类所有成员,基类的公用或保护成员的访问权限在派生中全部都按原样保留下来了,在派生外可以调用基类的公用成员函数访问基类的私有...
  • 可以实现代码的重用,例如,模板方法设计模式是抽象一个典型应用,假设某个项目的所有Servlet都要用相同的方式进行权限判断、记录访问日志和处理异常,那么就可以定义一个抽象的基类,让所有的Servlet都继承这...
  • C++基类派生

    2019-08-01 22:19:27
    基类和派生 1、::和: ::后接成员函数或变量 :继承 的构造函数不能继承,(即使继承了它的名字和派生的名字也不一样,不能成为派生的构造函数,更不能成为普通的...构造函数初始化列表以一个冒号开...
  • 派生基类的自动类型转换

    千次阅读 2017-12-23 21:30:11
    一个派生对象初始化和赋值给一个基类对象,事实上调用的是基类的拷贝构造函数和赋值操作符重载函数,因为这两个函数的参数是基类类型的const引用,所以还是基于引用的自动类型转换。  派生基类的自动类型...
  • C++继承(1.基类与派生

    千次阅读 2017-09-12 14:22:05
    继承是OOP的三个基本概念之一(数据抽象、继承、动态绑定),它让我们可以通过修改和扩展一个基类)来获得新的(派生),提高了代码的可重用性。1.基类与派生为了说明继承,我们首先需要一个...
  • 只有公用继承能较好地保留基类的特征,它保留了除构造函数和析构函数以外的基类所有成员,基类的公用或保护成员的访问权限在派生中全部都按原样保留下来了,在派生外可以调用基类的公用成员函数访问基类的私有...
  • 基类转派生

    千次阅读 2012-07-03 22:08:56
    1、如果你以一个"基类之指针"指向一个"派生之对象",那么经由该指针你只能调用该基类所定义的函数 2、如果你以一个“派生之指针”指向一个基类之对象”,你必须先做明显的转型操作(explicit cast),这种作法...
  • 基类与派生的转换  3种继承方式(公用、保护、私有继承)中,公用派生才是基类真正的子类型,它完整地继承了基类的功能。  不同类型数据之间在一定条件下可以进行类型的转换。基类与派生对象之间...
  • 基类中任何构造函数以外的非静态函数都可以是虚函数,关键字virtual只能出现在内部的声明语句之前而不能用于外部的函数定义。 3. 派生 派生构造函数 尽管在派生对象中含有从基类继承而来的成员,但是派生...
  • 基类指针指向派生是安全的,而派生指向基类则是不安全的
  • C++ 基类和派生

    2014-08-01 17:29:15
    转自C++ 基类和派生 本讲讨论基类和派生的基本概念。 ... 通过继承机制,可以利用已的数据类型来定义新的数据... 在C++语言中,一个派生可以从一个基类派生,也可以从多个基类派生。从一个基类派生的继承
  • 定义基类和派生

    2015-04-22 10:57:03
    作为继承关系中根节点的通常都会定义一个虚析构函数。 基类通常都应该定义一个虚析构函数,即使该函数不执行任何实际操作也是如此。成员函数与继承 在C++语言中,基类必须将它的两种成员函数区分开来:一种是...
  • 我们知道一般的赋值兼容,如double d, int i, int *ip; d = i 可以直接赋值, i = d 可以舍弃小数赋值,而 ip = 1024 则出现...1. 那么基类对象和派生对象是否存在赋值兼容关系? 存在,但是是单向的【从派生
  • #include using namespace std; class A { public: A(){}; virtual ~A(){}; virtual int Show()=0; }; class B:public A { public: B(){}; virtual ~B(){}; }; class C:public B ...pub
  • 基类与派生

    万次阅读 2012-07-10 11:36:48
    初学C++的时候,很多人都很头疼各种访问标号下基类与派生的关系,其实,死记硬背肯定不是一个好的办法,要知道它们之间的关系,先要分析一下访问标号是如何产生的: 在没有继承之前,的只有两用户:本身和...
  • 基类和派生

    2013-05-05 21:38:46
    * 继承意味着派生继承了基类的所有特性,基类的所有数据成员和成员函数自动成为派生的数据成员和成员函数。如: “形状”具有位置、大小、颜色等属性,可以移动、绘制等,由其派生出来的“圆”同样这些属性和...
  • 基类指针或引用只能用于调用基类方法,不能使用基类指针或引用指向派生方法。
  • 安全:派生对象也是一个基类对象 只能调用基类成员函数;如果调用派生成员,则编译错误 为了避免这一错误,必须把基类指针强制转换为派生指针(向下强制类型转换),这一操作危险性。 简单:利用派生...
  • 基类

    2020-06-18 19:23:37
    1.要使这个公共基类在派生中只产生一个子对象,必须对这个基类声明为虚继承,使这个基类成为虚基类。 2. 虚基类用于共同基类的场合 3. 声明虚基类的一般形式为: class 派生类名: virtual 继承方式 基类名 例:...
  • 但是基类对象无法被当做成派生对象,因为派生可能具有只有派生的成员。 所以,将派生指针指向基类对象的时候要进行显示的强制转换,否则会使基类对象中的派生成员成为未定义的。 总结:基类指针和派生...
  • 区分“派生对象”和“派生”对基类成员的访问权限。  “派生对象”对基类成员的访问权限: (1)对于公有继承,只有基类的公有成员可以被“派生对象”访问,其他(保护和私有)成员不能被访问。 (2)对于...
  • 派生内只可能访问基类的...派生对象和基类对象只能访问自个类的public成员 基类成员在继承后在派生中的权限:  基类权限: public private protected  继承权限:public 继承 public private
  • 派生基类的转换

    2016-06-02 12:59:23
    基类与派生对象之间赋值兼容关系,由于派生中包含从基类继承的成员,因此可以将派生的值赋给基类对象,在用到基类对象的时候可以用其子类对象代替。   具体表现在以下几方面: 派生对象可以...
  • 在C++中,我们允许 将派生对象赋给基类对象。(不允许将基类对象赋给派生对象) ...原因很简单,派生一般含有基类没有的成员,将派生赋给基类成员我们才能保证基类中每成员都能被赋值,用基类指...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 164,877
精华内容 65,950
关键字:

一个类只能有一个基类