精华内容
下载资源
问答
  • 赋值兼容规则

    2021-06-13 18:33:12
    赋值兼容规则 派生类如果是从基类公有继承的,则它会包含基类中除构造函数和析构函数外的所有成员,基类的公有成员也成为派生类的公有成员,又因为对象只能访问类的公有成员,所以基类对象具有的功能,派生类对象都...

    赋值兼容规则

    派生类如果是从基类公有继承的,则它会包含基类中除构造函数和析构函数外的所有成员,基类的公有成员也成为派生类的公有成员,又因为对象只能访问类的公有成员,所以基类对象具有的功能,派生类对象都有。这样就引出了赋值兼容规则。

    赋值兼容规则就是指在基类对象可以使用的地方都可以用公有派生类对象来代替。注意必须是公有派生类。赋值兼容规则中的代替有三种方式。鸡啄米通过一个例子分别说明。

    假设有基类Base,类Child是Base的公有派生类,base为Base类的对象,pBase为Base类指针,child为Child类的对象。代码如下:

    class Base
    {
        ...
    };
    class Child : public Base
    {
        ...
    };
    Base base, *pBase;
    Child child;
    

    那么根据赋值兼容规则,可以使用类Base对象的地方都可以使用类Child的对象来代替。这里的代替有三种:

    1.派生类的对象可以赋值给基类的对象。也就是将派生类对象从基类继承的成员的值分别赋值给基类对象相应的成员。例如:

    base = child;
    

    2.派生类对象的地址可以赋值给基类类型的指针。例如:

    pBase = &child;
    

    3.派生类对象可以用来初始化基类的引用。例如:

    Base &b = child;
    

    因为有了赋值兼容规则,有了上述三种赋值方式,所以函数的参数中有基类对象或者基类指针又或者基类引用时,我们可以直接传入派生类对象或者派生类对象的地址作为实参来执行相同的操作。

    这样的好处是什么呢?那就是我们想对基类及派生类的对象做相同的操作时,只要定义一个函数就行了,它的参数为基类对象或者基类指针也或者是基类引用。这样就大大提高了软件开发的效率。

    公有派生类对象可以代替基类对象使用,但是我们只能使用它从基类继承的成员,而无法使用它的新添成员。

    给大家举个例子说明下赋值兼容规则:

    类Base为基类,类Child0为Base的公有派生类,类Child1为类Child0的公有派生类。三个类中都定义了成员函数show()。

    #include <iostream>
    using namespace std;
    class Base           // 基类Base的声明
    {
    public:
        void show()    { cout << "Base::show()" << endl; }      // 公有成员函数show
    };
    class Child0 : public Base     // 类Base的公有派生类Child0的声明
    {
    public:
        void show()    { cout << "Child0::show()" << endl; }    // 公有成员函数show
    };
    class Child1 : public Child0   // 类Child0的公有派生类Child1的声明
    {
    public:
        void show()    { cout << "Child1::show()" << endl; }    // 公有成员函数show
    };
    void CallShow(Base *pBase)     // 一般函数,参数为基类指针
    {
        pBase->show();
    }
    int main()
    {
        Base base;                 // 声明Base类的对象
        Base *pBase;             // 声明Base类的指针
        Child0 ch0;                 // 声明Child0类的对象
        Child1 ch1;                 // 声明Child1类的对象
        pBase = &base;        // 将Base类对象base的地址赋值给Base类指针pBase
        CallShow(pBase);
        pBase = &ch0;            // 将Child0类对象ch0的地址赋值给Base类指针pBase
        CallShow(pBase);
        pBase = &ch1;            // 将Child1类对象ch1的地址赋值给Base类指针pBase
        CallShow(pBase);
        return 0;
    }
    

    在这里插入图片描述
    我们首先定义了一个函数CallShow,其参数pBase为基类Base类型的指针,根据赋值兼容规则,我们可以用公有派生类对象的地址为基类指针赋值,那么CallShow函数就可以处理这个类族的所有对象。

    在主函数中我们就分别把基类对象base的地址、派生类对象ch0的地址和派生类对象ch1的地址赋值给基类指针pBase,然后将pBase作为实参调用CallShow,在CallShow中调用了成员函数show。

    但是,根据上面所讲,将派生类对象的地址赋值给pBase以后,通过pBase只能访问派生类从基类继承的成员。

    所以即使指针pBase指向的是派生类对象ch0或者ch1,在CallShow中通过pBase也只能调用从基类Base继承的成员函数show,而不会调用Child0类或者Child1类的成员函数show。

    因此主函数中三次调用CallShow函数,都是访问的基类Base的成员函数show,输出都是Base::show()。

    这时我们深切的感受到,即使派生类对象代替了基类对象,它也只能产生基类的功能,自己的新功能无法体现。要想在代替以后同样能够实现自己的功能,就要用到面向对象设计的另一个特性–多态性。而本节学的赋值兼容规则是多态性的基础。

    展开全文
  • C++赋值兼容规则

    2021-06-09 19:17:55
    C++赋值兼容规则 基类与派生类对象之间的赋值兼容关系 不同类型数据之间的自动转换和赋值,称为赋值兼容。在基类和派生类对象之间也存在赋值兼容关系,基类和派生类对象之间的赋值兼容规则是指在需要基类对象的任何...

    C++赋值兼容规则

    基类与派生类对象之间的赋值兼容关系

    不同类型数据之间的自动转换和赋值,称为赋值兼容。在基类和派生类对象之间也存在赋值兼容关系,基类和派生类对象之间的赋值兼容规则是指在需要基类对象的任何地方,都可以使用公有派生类对象来替代

    根据赋值兼容规则,在基类Base的对象可以使用的任何地方,都可以用派生类Derived的对象来替代,但只能使用从基类继承来的成员。

    (1)派生类对象可以向基类对象赋值,即用派生类对象中从基类继承来的数据成员,逐个赋值给基类对象的数据成员。例如:

    Base b; //定义基类base的对象b
    Derived d; //定义基类Base的公有派生类Derived的对象d
    b=d; //用派生类Derived的对象对基类对象b赋值
    

    这样赋值的效果是,对象b中所有数据成员都将具有对象d中对应数据成员的值

    (2)派生类对象可以初始化基类对象的引用。例如:

    Base b; //定义基类Base的对象b
    Derived d; //定义基类Base的公有派生类Derived的对象d
    Base &br=d; //定义基类Base的对象的引用br,并用派生类Derived的对象d对其初始化
    

    (3)派生类对象的地址可以赋给指向基类对象的指针。例如:

    Derived d; //定义基类Base的公有派生类Derived的对象b
    Base *bp=&d; //把派生类对象的地址&d赋值给指向基类的指针bp
    			//也就是说使指向基类对象的指针bp也可以指向派生类对象d
    

    这种形式的转换,是在实际应用程序中最常见到的

    (4)如果函数的形参是基类对象或基类对象的引用,在调用函数时可以用派生类对象作为实参

    注:

    1. 声明为指向基类对象的指针可以指向它的公有派生类的对象,但不允许指向它的私有派生的对象
    2. 允许将一个声明为指向基类的指针指向其公有派生类的对象,但是不能将一个声明为指向派生类对象的指针指向其基类的一个对象
    展开全文
  • c++赋值兼容规则

    千次阅读 2017-11-11 09:03:17
    赋值兼容规则是指在需要父类对象的地方可以使用子类对象来代替:   通过public继承,子类得到了父类除构造/析构函数之外的所有成员,且所有成员的访问属性和父类的完全相同。这样,public继承的子类实际就具备了...

      赋值兼容规则是指在需要父类对象的地方可以使用子类对象来代替:

      通过public继承,子类得到了父类除构造/析构函数之外的所有成员,且所有成员的访问属性和父类的完全相同。这样,public继承的子类实际就具备了父类的所有功能,凡是父类能解决的问题,子类都可以解决。

      赋值兼容规则是发生在父类和子类之间的:

      (1) 子类的对象可以赋值给父类对象对象,过程会发生隐式类型转换
      (2) 父类类型的指针可以指向子类对象
      (3) 父类类型的引用可以用子类对象初始化

      发生赋值兼容后,子类对象只能被作为父类对象使用,即只能使用从父类继承而来的成员。

    展开全文
  • (34.2)赋值兼容规则

    2020-01-19 22:53:29
    赋值兼容规则 1.赋值兼容规则 赋值兼容规则是指:在需要基类对象的任何地方,都可以使用公有派生类的对象来代替 通过公有继承,派生类得到了基类中除构造函数,析构函数之外的所有成员。这样,共有派生类实际就...

    1.赋值兼容规则

    • 赋值兼容规则是指:在需要基类对象的任何地方,都可以使用公有派生类的对象来代替 (如果是私有继承或者保护继承,那么他就是错误的!!)

    • 通过公有继承,派生类得到了基类中除构造函数,析构函数之外的所有成员。这样,公有派生类实际就具备了基类的所有功能,凡是基类能解决的问题,公有派生类都可以解决 (公有派生类继承的,原来是公有的,现在还是公有的,原来是保护的,现在还是保护的,原来基类是保护的,那么公有派生类是不可以使用的)

    • 赋值兼容规则中所指的替代包括以下的情况:
      (1)派生类的对象可以赋值给基类对象
      (2)派生类的对象可以初始化基类的引用
      (3)派生类对象的地址可以赋值给指向基类的指针(即:基类的指针可以指向派生类的对象)

    • 派生类的对象可以赋值给基类,但是基类不能赋值给派生类

    • eg

    class Base { }//基类
    class Drive :public Base { };//公有派生类
    Base b,*pb;//定义基类对象,指针
    Derive d;//定义派生类对象
    
    此时,其支持下面三种操作:
    b=d;//派生类对象赋值给基类,复制基类继承部分
    Base &rb=d;//基类引用到派生类对象
    pb=&d;//基类指针指向派生类对象
    
    总结:赋值兼容规则是C++多态性的重要基础之一
    
    • eg2:
    # include <iostream>
    using namespace std;
    class man//基类man
    {
    	protected://保护成员在类外不能使用
    		int age;
    		string name;
    	public:
    		man(int a, string n):age(a),name(n){ }//基类的构造函数
    		void print()
    		{
    			cout<<"姓名:"<<name<<", 年龄:"<<age<<endl;
    		}
    		int get_age()
    		{
    			return age;
    		}
    		string get_name()
    		{
    			return name;
    		}
    };
    
    class superm:public man//派生类superman,公有继承
    {
    	private:
    		int force_value;//派生类增加的数据成员
    	public:
    		//因为继承了基类的数据成员age和name,所以需要对三个数据成员进行初始化
    		//派生类的构造函数需要调用基类的构造函数
    		superman(int a, string n, int f):man(a,n),force_value(f){ }//派生类的构造函数
    	void print()//派生类的print覆盖了基类的print函数
    	{
    		cout<<"姓名: "<<name<<", 年龄: "<<age<<"武力值:"<<force_value<<endl;
    	}
    	void fly()//派生类增加的成员函数
    	{
    		cout<<"fly, fly, fly..."<<endl;
    	}
    };
    
    int work(man a)//形参为基类对象
    {
    	if (a.get_age()>=20)
    		return 1;
    	else
    		return 0;
    }
    
    int main()
    {
    		int n;
    		man i(25,"jerry");
    		superman j(20,"clark",100);
    		//赋值兼容规则:(1)派生类的对象可以赋值给基类对象
    		n=work(j);//实参为派生类对象,看看超人是否能胜任工作?(这样的讲解无敌)
    		//get_age()是superman类继承过来的
    		
    		if (n!=0)
    			cout<<j.get_name()<<"可以胜任此项工作"<<endl;
    		else
    			cout<<j.get_name()<<"不可以胜任此项工作。"<<endl;
    		
    		return 0;
    }
    
    • eg3:将eg2改一下
    int work(man *a)//形参为基类指针
    {
    	if (a->get_age()>=20)
    		return 1;
    	else
    		return 0;
    }
    
    int main()
    {
    	int n;
    	man i(25, "jerry");
    	superman j(20,"clark",100);
    	//赋值兼容规则:(3)派生类对象的地址可以赋值给指向基类的指针(即:基类的指针可以指向派生类的对象)
    	n=work(&j);//实参为派生类对象的地址
    	
    	if (n!=0)
    		cout<<j.get_name()<<"可以胜任此项工作"<<endl;
    	else
    		cout<<j.get_name()<<"不可以胜任此项工作。"<<endl;
    		
    	return 0;
    	
    }
    
    • eg4:将eg2再修改一下
    int work(man &a)//形参为基类引用
    {
    	if (a.get_age()>=20)
    		return 1;
    	else
    		return 0;
    }
    
    int main()
    {
    	int n;
    	man i(25,"jerry");
    	superman j(20,"clark",100);
    	//基类的引用,用派生类的对象初始化,a就是j,j就是a
    	//赋值兼容规则:(1)派生类的对象可以赋值给基类对象
    	n=work(j);//实参为派生类对象
    	
    	if (n!=0)
    		cout<<j.get_name()<<"可以胜任此项工作"<<endl;
    	else
    		cout<<j.get_name()<<"不可以胜任此项工作。"<<endl;
    		
    	return 0;
    	
    }
    
    
    展开全文
  • 赋值兼容规则】 派生类对象可以赋值给基类对象。即用派生类对象中从基类继承来的数据成员,逐个赋值给基类对象的数据成员。 派生类对象的地址可以赋值给基类对象的指针。 派生类对象可以用来初始化基类对象的引用...
  • 同名隐藏,子类和父类的赋值兼容规则 子类和父类的赋值兼容规则 1.同名隐藏(非常重要) 当子类的成员方法(show)和父类的成员方法(show)的名字相同的时候,父类的所有(show)方法,都不能用子类的对象来调用...
  • 子类函数名与父类函数名相同,子类函数将隐藏所有父类的同名函数基类与派生类赋值兼容规则1.派生类的对象可以赋值给基类的对象,这时是吧派生类对象中从对应基类中继承来的隐藏对象赋值给基类对象(对象的切片)。反...
  • /* 赋值兼容规则 作者:qpz */#include #include using namespace std;class Base{private: int x; int y;public: Base(int x,int y) { this->x=x; this->y=y; }};class Derived:public Base{private: int z;...
  • 赋值兼容规则是指在需要基类对象的任何地方都可以使用公有派生类的对象来替代。通过公有继承,派生类得到了基类中除构造函数、析构函数之外的所有成员,而且所有成员的访问控制属性也和基类完全相同。这样,公有派生...
  • //program 14.7.1.cpp 共有派生的赋值兼容规则 #include<iostream> using namespace std; class A { int a = 0; public: void print() { cout << "a=" << a << endl; } protected: ...
  • C++赋值兼容规则和多态

    千次阅读 2012-01-09 23:13:25
    赋值兼容规则是指在需要基类对象的任何地方都可以使用公有派生类的对象来替代。通过公有继承,派生类得到了基类中除构造函数、析构函数之外的所有成员,而且所有成员的访问控制属性也和基类完全相同。这样,公有派生...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 429
精华内容 171
关键字:

兼容赋值规则