精华内容
下载资源
问答
  • 在派生类中调用基类方法

    千次阅读 2009-04-10 09:18:00
    base 关键字用于从派生类中访问基类的成员: 调用基类上已被其他方法重写的方法。... 示例: 在派生类中调用基类方法。 // base 关键字// 访问基类成员using System;public class BaseClass{ protected string _cl

    base 关键字用于从派生类中访问基类的成员:

    调用基类上已被其他方法重写的方法。
    指定创建派生类实例时应调用的基类构造函数。
    基类访问只能在构造函数、实例方法或实例属性访问器中进行。

    示例:

     

    在派生类中调用基类方法。
    // base 关键字
    // 访问基类成员
    using System;

    public class BaseClass
    {
        protected string _className = "BaseClass";

        public virtual void PrintName()
        {
            Console.WriteLine("Class Name: {0}", _className);
        }
    }

    class DerivedClass : BaseClass
    {
        public string _className = "DerivedClass";

        public override void PrintName()
        {
            Console.Write("The BaseClass Name is {0}");
            //调用基类方法
            base.PrintName();
            Console.WriteLine("This DerivedClass is {0}", _className);
        }
    }

    class TestApp
    {
        public static void Main()
        {
            DerivedClass dc = new DerivedClass();
            dc.PrintName();
        }
    }

    /**//*
    控制台输出:
    The BaseClass Name is BaseClass
    This DerivedClass is DerivedClass
    */
    在派生类中调用基类构造函数。
    // keywords_base2.cs
    using System;
    public class BaseClass
    {
        int num;

        public BaseClass()
        {
            Console.WriteLine("in BaseClass()");
        }

        public BaseClass(int i)
        {
            num = i;
            Console.WriteLine("in BaseClass(int {0})", num);
        }
    }

    public class DerivedClass : BaseClass
    {
        // 该构造器调用 BaseClass.BaseClass()
        public DerivedClass() : base()
        {
        }

        // 该构造器调用 BaseClass.BaseClass(int i)
        public DerivedClass(int i) : base(i)
        {
        }

        static void Main()
        {
            DerivedClass dc = new DerivedClass();
            DerivedClass dc1 = new DerivedClass(1);
        }
    }

    /**//*
    控制台输出:
    in BaseClass()
    in BaseClass(1)
    */

    注意点

    从静态方法中使用 base 关键字是错误的。
    base 主要用于面向对象开发的对态这方面,在示例2中有体现。
    this
    this 关键字引用类的当前实例。

    以下是 this 的常用用途:

    限定被相似的名称隐藏的成员
    将对象作为参数传递到其他方法
    声明索引器
    示例:

     综合示例。
    // this 关键字
    // keywords_this.cs
    using System;
    class Employee
    {
        private string _name;
        private int _age;
        private string[] _arr = new string[5];

        public Employee(string name, int age)
        {
            // 使用this限定字段,name与age
            this._name = name;
            this._age = age;
        }

        public string Name
        {
            get { return this._name; }
        }

        public int Age
        {
            get { return this._age; }
        }

        // 打印雇员资料
        public void PrintEmployee()
        {
            // 将Employee对象作为参数传递到DoPrint方法
            Print.DoPrint(this);
        }

        // 声明索引器
        public string this[int param]
        {
            get { return _arr[param]; }
            set { _arr[param] = value; }
        }

    }
    class Print
    {
        public static void DoPrint(Employee e)
        {
            Console.WriteLine("Name: {0}/nAge: {1}", e.Name, e.Age);
        }
    }

    class TestApp
    {
        static void Main()
        {
            Employee E = new Employee("Hunts", 21);
            E[0] = "Scott";
            E[1] = "Leigh";
            E[4] = "Kiwis";
            E.PrintEmployee();

            for(int i=0; i<5; i++)
            {
                Console.WriteLine("Friends Name: {0}", E[i]);
            }

            Console.ReadLine();
        }
    }

    /**//*
    控制台输出:
    Name: Hunts
    Age: 21
    Friends Name: Scott
    Friends Name: Leigh
    Friends Name:
    Friends Name:
    Friends Name: Kiwis
    */
    注意点

    由于静态成员函数存在于类一级,并且不是对象的一部分,因此没有 this 指针。在静态方法中引用 this 是错误的。
    索引器允许类或结构的实例按照与数组相同的方式进行索引。索引器类似于属性,不同之处在于它们的访问器采用参数。

    展开全文
  • 在派生类中实现与基类方法名相同的方法,返回值和特征标都一样,在派生类中就相当于覆盖基类的该方法。 #include &lt;iostream&gt; using namespace std; class Fish{ private: bool isFreshWaterFish; ...

    派生类覆盖基类方法

    在派生类中实现与基类方法名相同的方法,返回值和特征标都一样,在派生类中就相当于覆盖基类的该方法。

    #include <iostream>
    using namespace std;
    class Fish{
    private:
    	bool isFreshWaterFish;
    public:
    	Fish(bool isFreshWater):isFreshWaterFish(isFreshWater){}
    	void Swim(){
    		if(isFreshWaterFish){cout<<"Swim in lake"<<endl;}
    		else{cout<<"Swim in sea"<<endl;}
    	}
    } 
    class Tuna:public Fish{
    public:
    	Tuna():Fish(false){}
    	void Swim(){
    		cout<<"Tuna swim in sea"<<endl;
    	}
    }
    int main(){
    	Tuna myTuna;
    	myTuna.Swim();
    	return 0;
    }
    输出:
    Tuna swim in sea
    

    那么如何在main()调用基类实现的,但是被派生类覆盖的方法?
    需要使用作用域标识符(::)

    Tuna myTuna;
    myTuna.Fish::Swim();//调用基类中实现的方法
    myTuna.Swim();//调用派生类实现的方法
    

    那么又怎么在派生类中调用基类实现的方法?

    Fish::Swim();
    

    在派生类中隐藏基类的方法

    #include <iostream>
    using namespace std;
    
    class Fish{
    private:
    	bool isFreshWaterFish;
    public:
    	Fish(bool isFreshWater):isFreshWaterFish(isFreshWater){}
    	void Swim(){
    		cout<<"Swim in ..."<<endl;
    	}
    	void Swim(bool isFreshWater){
    		if(isFreshWaterFish){cout<<"Swim in lake"<<endl;}
    		else{cout<<"Swim in sea"<<endl;}
    	}
    } 
    class Tuna:public Fish{
    public:
    	Tuna():Fish(false){}
    	void Swim(){
    		cout<<"Tuna swim in sea"<<endl;
    	}
    }
    int main(){
    	Tuna myTuna;
    	myTuna.Swim();
    	//myTuna.Swim(false);
    	return 0;
    }
    
    

    其中myTuna.Swim(false);将会导致编译错误。由于派生类实现自己的Swim()方法,覆盖基类的Swim()方法以及重载方法。
    解决方案有:

    1. 使用作用域表示符myTuna.Fish::Swim();
    2. 使用关键字using解除对Fish::Swim()的隐藏
    class Tuna {
    	public:
    	using Fish::Swim;
    	void Swim(){
    		cout<<"Tuna swim in sea"<<endl;
    	}
    }
    
    1. 在派生类中实现基类所有重载的版本(Tuna类中覆盖Fish类)

    切除问题

    将一个派生类实例化对象,复制给其基类对象,编译器只复制基类所能承受的部分,这是一种无意间造成的裁剪数据,所以一般不要使用值传递,应该使用基类指针或者const引用的方式传递。

    展开全文
  • C#在派生类中调用基类成员

    千次阅读 2019-10-04 21:57:35
    C#的派生类中,我们可以使用base关键字调用基类中的公有或者受保护成员。这些成员只能是构造函数、实例方法或者实例属性。 base关键字调用基类成员的语法格式如下: base . identifier或 base[expression-list]...

    一、在派生类中调用基类成员

    在C#的派生类中,我们可以使用base关键字调用基类中的公有或者受保护成员。这些成员只能是构造函数、实例方法或者实例属性。

    base关键字调用基类成员的语法格式如下:

    base . identifier或

    base[expression-list]注意:

    ?base关键字不能用在派生类的静态方法中。

    ?必须显式添加基类的构造函数。

    二、示例
      
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
     
    namespace Test
    {
        class Program
        {
            public class A                     // 基类
            {
                protected string name; // 受保护字段成员,可在当前类和派生类中访问
                protected int age;             // 受保护字段成员
                public A(string name, int age) // 实例构造函数
                {
                    this.name = name;
                    this.age = age;
                }
                public void Show()             // 公共方法
                {
                    Console.WriteLine("基类-name:{0} age:{1}",name,age);
                }
            }
            public class B : A                 // 这是派生类,以A作为基类
            {
                private int ID;                // 派生类的成员
                public B(int ID, string name, int age)
                    : base(name, age)          // 调用直接基类的实例构造函数
                {
                    this.ID = ID;
                    Console.WriteLine("派生类B的构造函数");
                }
                new public void Show() // 用new关键字隐藏基类中的同名方法
                {
                    Console.WriteLine("ID:{0}", ID);
                    Console.WriteLine("派生类B的Show方法");
                    base.Show();               // 调用基类的方法
                }
            }
            static void Main(string[] args)
            {
                // C#在派生类中调用基类成员-www.baike369.com
                B b = new B(100,"BaiXue",18);  // 创建类的实例
                b.Show();                      // 调用派生类B的方法
                Console.ReadLine();
            }
        }
    }

    运行结果:
     
    派生类B的构造函数
    ID:100
    派生类B的Show方法
    基类-name:BaiXue age:18

    转载于:https://www.cnblogs.com/melao2006/p/4239253.html

    展开全文
  • /*有些基类的方法在派生类被覆盖,但有时我们需要调用基类方法。 * 这里提供了两种方式去调用基类被覆盖的方法(均使用作用域解析运算符::)。 * 1: 直接在派生类中调用被覆盖的基类方法,如 Person::CheckPerson()...
    #include <iostream>
    using namespace std;
    
    /*有些基类的方法在派生类被覆盖,但有时我们需要调用基类的方法。
    * 这里提供了两种方式去调用基类被覆盖的方法(均使用作用域解析运算符::)。
    * 1: 直接在派生类中调用被覆盖的基类方法,如 Person::CheckPerson() ;
    * 2:  使用派生类对象调用被覆盖的基类方法,如 Tom.Person::CheckPerson();
    */
    class Person {
    protected: //只能在派生类内部访问protected成员,外部不可访问
    	bool man;
    public: // public权限,可被派生类访问
    	void CheckPerson();
    
    	Person(bool initValue) { //构造函数的重载,带初始值
    		man = initValue;
    		cout << "Person constructor" << endl;
    	}
    
    	~Person() {
    		cout << "~Person deconstructor" << endl;
    	}
    };
    
    void Person::CheckPerson() {
    	if (man)
    		cout << "Person is man" << endl;
    	else
    		cout << "Person is woman" << endl;
    }
    
    class Man: public Person {  //public继承,可访问基类public和protected权限的成员
    public:  
    	void CheckPerson(); //覆盖基类的方法
    	Man() : Person(true) {}; //利用初始化列表,对基类的成员进行初始化(基类重载构造函数需要初始化值)
    	~Man() {};
    };
    
    /*类Man继承了Person的public和protected成员,这里覆盖基类中的函数CheckPerson()*/
    void Man::CheckPerson() { //覆盖基类中的函数CheckPerson()
    	if (man) {
    		Person::CheckPerson();//使用作用域解运算符::,可调用被覆盖的基类方法
    		cout << "calss function is covered: man" << endl;
    	}
    	else {
    		cout << "calss function is covered: woman" << endl;
    	}
    }
    
    int main()
    {
    	Man Tom;
    	Tom.CheckPerson(); //派生类外部可调用继承的基类public成员
    	Tom.Person::CheckPerson(); //使用作用域解运算符::,可调用被覆盖的基类方法
    	//Tom.man = false;   //编译出错,外部不可修改继承的protected成员
    	return 0;
    }

    output: 

    Person constructor
    Person is man
    calss function is covered: man
    Person is man
    ~Person deconstructor

    展开全文
  • 派生类中怎样调用基类的输出操作符重载函数,想输出基类的私有成员,利用子类的对象
  • 多态的使用方法是当基类指针指向派生类对象时,可以直接调用派生类重写的虚函数,而不是基类的虚函数。实现方法也是老生常谈,通过每个对象的虚函数表指针,去找属于自己类的虚函数执行。那如果用派生类指针指向...
  • 对于普通方法在派生类中用"."+"方法名"的方式调用基类方法,例如: 在基类中定义了一个do_something方法 #基类 func do_something(): print("parent:do something") 子类中调用它: func a_...
  • 尽管有时需要事件仅由基类引发,但大多数情形下,应该允许派生类调用基类事件。为此,您可以包含该事件的基类中创建一个受保护的调用方法。通过调用或重写此调用方法,派生类便可以间接调用该事件。 注意:不要...
  • 构造函数与基类的其他成员不同,不能被派生类继承,因此为了初始化基类中的成员变量,需要在派生类调用基类的构造函数(即显式调用),如果派送类没有调用则默认调用基类的无参构造函数(即隐式调用). 显式调用的方式...
  • C++派生类函数调用基类的函数

    万次阅读 2014-07-17 15:48:05
    MFC的程序,我们经常会看到下面的程序片段,
  • C++从派生类调用基类

    2021-01-13 15:10:10
    1、如何从派生类对象调用派生类覆盖的基类方法? class Base{ public: void foo(){cout<<“base”;} }; class Derived:public Base{ public: void foo(){cout<<“derived”;} } int main(){ Derived bar...
  • C++派生类中基类同名函数的调用问题

    万次阅读 多人点赞 2016-11-11 22:26:14
    一、派生类,即子类的函数与基类的函数的情况有以下三种。 1、不是同名函数 2、函数名相同,形参的个数或类型不同。 3、函数名相同,形参的个数和类型也相同。 二、接下来就这三种情况探讨子类调用基类函数的...
  • 最近写程序的时候发现,派生类对象的基类函数如果调用基类虚函数,则它将调用的是派生类的对应函数,而不是我想调用的基类的对应函数。 下面用一个例子来说明: //基类 class Base { public: void funA(); virtual...
  • 基本了解了虚函数的机制,可是现在有一个问题,delete一个指向派生类基类指针的时候(基类的析构函数定义为virtual),运行时是如何分别找到派生类基类的析构函数的?
  • 派生类调用基类构造函数

    千次阅读 2020-05-25 22:40:41
    不错的派生类调用基类构造函数 #include<iostream> using namespace std; class BASE{ public: /*****************found1*****************/ int i; BASE(int i){cout<<"调用基类BASE的构造函数:"<...
  • 《Visual C++2012入门经典(第6版)》实例,在派生类的构造函数中调用基类的构造函数
  • 1、利用多态调用不同方法 //.h Class Base{ public: virtual ~Base() {}; virtual funcA(); funcB(); funcC(); } Class Child:Base{ public: virtual funcA(); funcB(); } //.cpp Base * ptr1 = new Base(); ...
  • 定义一个基类Base,有两个公共成员函数fun1()和fun2(),如果公有派生出Derived类,Derived类重载了基类的成员函数fun1(),没有重载基类的成员函数fun2(),如何在派生类的函数中调用基类的成员函数fn1(),fn2()?...
  • 当创建一个派生类的对象时,系统首先自动创建一个基类对象,也就是说,调用派生类构造函数创建派生类对象之前,系统首先调用基类的构造函数创建基类对象。当派生类对象生命期结束时,首先调用派生类的析构函数,...
  • 一个常见的派生类访问基类成员变量的例子:template&lt;int dim&gt;class A{ public: A():b(2){} int b;};template&lt;int dim&gt;class B:public A&lt;dim&gt;{public: B(){} void f(){...
  • 派生类虚函数调用基类版本

    千次阅读 2012-12-04 10:27:02
    C++ primer 这本书上有这么两句话“派生类虚函数...当你实现派生类虚函数B : foo时,如果函数体内需要调用基类的虚函数版本时,需要显式使用基类的作用域操作符A::foo(),否则foo()就会在派生类作用域内调用派生类
  • 基类写了默认的构造函数,子类未明确调用 :(√) :这个情况,子类就可以默认调用到默认的构造函数 基类写了的默认构造函数,子类明确调用 :(√) :这个情况,子类就可以默认调用到默认的构造函数 基类没有写...
  • 派生类调用基类的构造函数

    千次阅读 2012-10-16 20:26:25
    在派生类中需要构造函数时,基类的默认构造函数可以被隐式地调用,但如果基类的所有构造函数都带有参数,那么这时基类的构造函数必须在派生类中显示的调用。 class base { public:  base(string name, int num)...
  • 调用基类上已被其他方法重写的方法。 二 指定创建派生类实例时应调用的基类构造函数。  base使用通用规则: ①尽量少用或者不用base和this。除了避开子类的名称冲突和一个构造函数调用其他的构造函数之外...
  • 调用基类上已被其他方法重写的方法。 指定创建派生类实例时应调用的基类构造函数。 基类访问只能构造函数、实例方法或实例属性访问器...通过使用 base 关键字,可以从派生类中调用基类上的 Getinfo 方法。...
  • 在派生类环境基类对象 好像 不能访问 自己的 保护成员
  • 派生类对象如何调用基类的成员函数,特别是protected的成员函数? 2、 如何通过基类对象访问派生类的成员函数,特别是基类没有定义的某些方法? 3、 建立对象时,调用构造函数的顺序,析构函数的...
  • 可以使用super()这个BIF函数例:class Derived(Base): def meth(self): super(Derived,self).meth()
  • 定义一个基类Base,有两个公共成员函数fun1()和fun2(),如果私有派生出Derived,如何通过Derived的对象调用基类的函数fun1()和fun2()? 源代码 #include "stdafx.h" #include<iostream> using namespace ...
  • //调用基类上已被其他方法重写的方法。 //指定创建派生类实例时应调用的基类构造函数。 //基类访问只能构造函数、实例方法或实例属性访问器进行。 using System; using System.Collections.Generic; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 136,486
精华内容 54,594
关键字:

在派生类中调用基类的方法