C#基础(七)虚函数

若一个实例方法声明前带有virtual关键字,那么这个方法就是虚方法。
虚方法与非虚方法的最大不同是,虚方法的实现可以由派生类所取代,这种取代是通过方法的重写实现的(以后再讲)
虚方法的特点:
虚方法前不允许有static,abstract,或override修饰符
虚方法不能是私有的,因此不能使用private修饰符
虚方法的执行:
我们知道一般函数在编译时就静态地编译到了执行文件中,其相对地址在程序运行期间是不发生变化的,
而虚函数在编译期间是不被静态编译的,它的相对地址是不确定的,它会根据运行时期对象实例来动态判断要调用的函数,
其中那个申明时定义的类叫申明类,那个执行时实例化的类叫实例类。
如:A a =new B(); 其中A是申明类,B是实例类。
1.当调用一个对象的函数时,系统会直接去检查这个对象申明定义的类,即申明类,看所调用的函数是否为虚函数;
2.如果不是虚函数,那么它就直接执行该函数。而如果是一个虚函数,那么这个时候它就不会立刻执行该函数了,而是开始检查对象的实例类。
3.在这个实例类里,他会检查这个实例类的定义中是否有实现该虚函数或者重新实现该虚函数(通过override关键字)的方法,
如果有,它就不会再找了,而是马上执行该实例类中实现的虚函数的方法。而如果没有的话,系统就会不停地往上找实例类的父类,
并对父类重复刚才在实例类里的检查,直到找到第一个重载了该虚函数的父类为止,然后执行该父类里重载后的函数。
例1:

    class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new A();   // 定义一个a这个A类的对象.这个A就是a的申明类,实例化a对象,A是a的实例类  
             a.Sum();
             Console.Read();
        }
    }

执行a.Sum:
1.先检查申明类A 2.检查到是sum是虚拟方法 3.转去检查实例类A,结果是题本身 
4.执行实例类A中实现Sum的方法 5.输出结果 I am A Class,I am virtual sum(). 
例2:

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A
    {
        public override void Sum() // 重新实现了虚函数
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();  // 定义一个a这个A类的对象.这个A就是a的申明类,实例化a对象,B是a的实例类  
             a.Sum();
             Console.Read();
        }
    }

执行a.Sum:
1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类B,有重写的方法 4.执行实例类B中的方法 5.输出结果 I am B Class,I am override sum().
例3:

    class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A
    {
        public override void Sum() // 重新实现了虚函数
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class C : B
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new C();// 定义一个a这个A类的对象.这个A就是a的申明类,实例化a对象,C是a的实例类  
             a.Sum();
             Console.Read();
        }
    }

执行a.Sum:
1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类C,无重写的方法 4.转去检查类C的父类B,有重写的方法
5.执行父类B中的Sum方法 6.输出结果 I am B Class,I am override sum().  
例4:

   class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A
    {
        public new void Sum() //覆盖父类里的同名函数,而不是重新实现
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();
             a.Sum();
             Console.Read();
        }
    }

执行a.Sum:
1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类B,无重写的(这个地方要注意了,虽然B里有实现Sum(),但没有使用override关键字,所以不会被认为是重写) 4.转去检查类B的父类A,就为本身 5.执行父类A中的Sum方法 6.输出结果 I am A Class,I am virtual sum().  
那么如果在例4里,申明的是类B呢?

    class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A
    {
        public new void Sum() //覆盖父类里的同名函数,而不是重新实现
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             B b=new B();
             b.Sum();
             Console.Read();
        }
    }

执行B类里的Sum(),输出结果I am B Class,I am new sum(). 
可以使用抽象函数重写基类中的虚函数吗?
答案是可以的。

    class A
    {
        public virtual void PrintFriends()
        {
            Console.WriteLine("A.PrintFriends()");
        }
    }
    abstract class B : A
    {
        public abstract override void PrintFriends();   //使用override 修饰符,表示抽象重写了基类中该函数的实现
    }
    abstract class C : A
    {
        public abstract new void PrintFriends();        //使用 new 修饰符显式声明,表示隐藏了基类中该函数的实现
    }

密封类可以有虚函数吗?
可以,基类中的虚函数将隐式的转化为非虚函数,但密封类本身不能再增加新的虚函数

    class A
    {
        public virtual void Fun()
        {
            Console.WriteLine("I am A.");
        }
    }
    sealed class Program:A
    {
        public override void Fun()
        {
            Console.WriteLine("I am B.");
        }
        static void Main(string[] args)
        {
            Program p = new Program();
            p.Fun();
            Console.Read();
        }
    }

原文地址:https://www.cnblogs.com/gracewolf/p/8425677.html

时间: 2024-10-16 08:05:29

C#基础(七)虚函数的相关文章

C++基础篇--虚函数原理

虚函数算是C++最关键和核心的内容之一,是组件的基础.下面先列出一些相关名词,再围绕它们举例说明虚函数的本质实现原理. 基础概念(英文部分来自C++编程思想) 1)绑定:Connectinga function call to a function body is called binding.(把函数调用和函数实现关联的过程) 2)早绑定:Whenbinding is performed before the program is run (by the compiler and linker

【核心基础】虚函数

本节研究虚函数的相关问题: 虚函数表 无继承 代码片段 class Animal { public: Animal(int age) : _age(age) { } virtual void f() { cout << "Animal::f " << _age << endl; } virtual void g() { cout << "Animal::g " << _age << endl;

C++基础:虚函数、重载、覆盖、隐藏&lt;转&gt;

转自:http://www.2cto.com/kf/201404/291772.html 虚函数总是跟多态联系在一起,引入虚函数可以使用基类指针对继承类对象进行操作! 虚函数:继承接口(函数名,参数,返回值),但是实现不继承(函数体) 非虚函数:继承接口,也继承实现: 1)虚析构函数(当一个类打算作为基类使用时候,其析构函数必须是虚函数) 构造函数可以为虚函数吗? 不可以,在生成对象的时候,必须向编译器明确指定要生成什么类型的对象,因而不存在虚函数的问题:只有当对象已经存在,我用什么接口去操作它

JavaScript 基础(七) 箭头函数 generator Date JSON

ES6 标准新增了一种新的函数: Arrow Function(箭头函数). x => x *x 上面的箭头相当于: function (x){ return x*x; } 箭头函数相当于匿名函数,并且简化了函数定义.一种像上面的,只包含一个表达式, 连{ ... }和return都省略掉了.还有一种可以包含多条语句,这时候就不能省略{ ... }和return: x =>{ if(x > 0){ return x * x; }else{ return -x *x; } } 如果参数不是

Python基础七(函数)

函数概述 函数:组织好的.可重复使用的.杉树能提高应用的模块性和代码的重复利用性.Python提供了很多的内置函数,比如len()等等,可以自行定义函数. 函数的定义 def 函数名(参数列表):   #函数定义 函数体 函数名() #函数执行 def namePrint(): #函数定义,这是无参数函数 print("我的名字是:发发") name() #执行函数 def func2(a): #定义了一个有形参的函数 print(a) func2("123") #

6、多态性-3、虚函数

虚函数是动态绑定的基础.虚函数必须是非静态的成员函数,虚函数经过派生之后,在类族中就可以实现运行过程中的多态. 根据类型兼容规则,可以使用派生类的对象代替基类对象.如果用基类类型的指针指向派生类对象,就可以通过这个指针来访问该对象,问题是访问到的只是从基类继承来的同名成员.解决这一问题的办法是:如果需要通过基类的指针指向派生类的对象,并访问某个与基类同名的成员,那么首先在基类中将这个同名函数说明为虚函数.这样,通过基类类型的指针,就可以使属于不同派生类的不同对象产生不同的行为,从而实现了运行过程

c++ 基础(七) 函数覆盖,虚函数,纯虚函数对比

1.函数覆盖 ClassA , ClassB ,其中ClassB继承ClassA 类定义如下: #ifndef _CLASSA_H #define _CLASSA_H #include <iostream> using namespace std; class ClassA { public: ClassA(void); ~ClassA(void); void method(); }; #endif #include "stdafx.h" #include "Cl

C++基础(纯虚函数与抽象类)

C++基础之纯虚函数与抽象类 引言 纯虚函数在C++编程中的地位很重要,其关联到了设计模式中"接口"的概念. 语法 纯虚函数的语法: 1.  将成员函数声明为virtual 2.  后面加上 = 0 3.  该函数没有函数体 1 class <类名> 2 { 3 virtual <类型><函数名>(<参数表>) = 0; 4 - 5 }; 例如: 1 class CmdHandler 2 { 3 virtual void OnComman

第七章、函数基础之定义函数的三种方式03

目录 第七章.函数基础之定义函数的三种方式03 一.无参函数 二.有参函数 三.空函数 第七章.函数基础之定义函数的三种方式03 一.无参函数 定义函数时参数是函数体接收外部传值的一种媒介 在函数阶段括号没有参数就是无参函数.调用时不需要传入实参 如果函数体代码逻辑不需要依赖外部传入值,必须定义成无参函数 def func(): print('hello nick') func() # hello nick 二.有参函数 在函数阶段括号有参数就是有参函数.调用时需要传入实参 如果函数体代码逻辑需