精华内容
下载资源
问答
  • Dynamic动态类型

    千次阅读 2019-03-05 13:06:47
    什么是动态类型 了解什么是动态类型首先我们了解静态类型,在我们平时定义一个int i=1就是静态类型,静态类型就是我们在没有编译的时候已经明确的知道他是一个int类型,动态语言是我们在运行时才会知道的类型。所以...

    什么是动态类型

    了解什么是动态类型首先我们了解静态类型,在我们平时定义一个int i=1就是静态类型,静态类型就是我们在没有编译的时候已经明确的知道他是一个int类型,动态语言是我们在运行时才会知道的类型。所以我们在编写动态类型的时候是无法使用vs的智能提示,因为编译器也不知道他是一个什么类型。

    dynamic i = 1;
    Console.WriteLine(i.GetType());
    dynamic str = "1";
    Console.WriteLine(str.GetType());

    引用一张结构图

    从图中可以看出,DLR是建立在CLR的基础之上的,其实动态语言运行时是动态语言和C#编译器用来动态执行代码的库,它不具有JIT编译,垃圾回收等功能。DLR通过它的绑定器(binder)和 调用点(callsite),元对象来把代码转换为表达式树,然后再把表达式树编译为IL代码,最后 由CLR编译为本地代码(DLR就是帮助C#编译器来识别动态类型)

    dynamic和var区别

    var关键字不过是一个指令,它告诉编译器根据变量的初始化表达式来 推断类型。(记住var并不是类型),而dynamic是类型,但是编译时不属于CLR 类型(指的int,string,bool,double等类型,运行时肯定CLR类型中一种的),它是包含了 System.Dynamic.DynamicAttribute特性的System.Object类型,但与object又不一样,不一样主要体现在动态类型不会在编译时时执行显式转换

    使用动态类型的优点

    1.减少强类型的转换

    2.延迟加载

    3.调用C#类型中不存在的其他语言的类型

    使用动态类型的缺点

    1.没有智能提示

    2.需要预先知道接收的数据结构

    动态语言的约束

    1不能用动态类型作为扩展方法的参数

    2委托和动态类型不能隐式转换

    3动态类型不能调用构造函数和静态方法

    4类型声明和泛型类型参数

    5类型声明和泛型类型参数不能声明一个基类为dynamic的类型,也不能将dynamic用于类型参数的约束,或作为类型 所实现的接口的一部分

    实现动态行为

    我们实现动态行为微软给我们提供了三种方式,下面我们来试一试:

    使用ExpandObject

    static void Main(string[] args)
    {
        dynamic expand = new ExpandoObject();
        //动态为expand类型绑定属性
        expand.Name = "王麻子";
        expand.Age = 24;
        //动态为expand类型绑定方法
        expand.AddMethod = (Func<int, string>)(x => $"你传进来的是{x}");                                                
                
        //调用expand类型的属性和方法												
        Console.WriteLine($"姓名:{expand.Name}\n年龄:{expand.Age}\n绑定方法:{expand.AddMethod(666)}");
        Console.Read();	
    }
    姓名:王麻子
    年龄:24
    绑定方法:你传进来的是666

     

    使用DynamicObject

    class DynamicType : DynamicObject
    {
        //	重写方法,													
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            Console.WriteLine(binder.Name + "方法被调用");
            result = null;
            return true;
        }
        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            Console.WriteLine(binder.Name + "属性被设置," + "设置的值为:" + value);
            return true;
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            dynamic dynamicobj = new DynamicType();
            dynamicobj.CallMethod();
            dynamicobj.Name = "王麻子";
            dynamicobj.Age = "24";
            Console.Read();
        }
    }
    CallMethod方法被调用
    Name属性被设置,设置的值为:王麻子
    Age属性被设置,设置的值为:24

     

    实现IDynamicMetaObjectProvider接口

    class Metadynamic : DynamicMetaObject
    {
        internal Metadynamic(Expression expression, DynamicType2 value) : base(expression, BindingRestrictions.Empty, value) { }
        //重写响应成员调用方法								
        public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
        {
            //获得真正的对象												
            DynamicType2 target = (DynamicType2)base.Value;
            Expression self = Expression.Convert(base.Expression, typeof(DynamicType2));
            var restrictions = BindingRestrictions.GetInstanceRestriction(self, target);
            //输出绑定方法名												
            Console.WriteLine(binder.Name + "方法被调用了");
            return new DynamicMetaObject(self, restrictions);
        }
    }
    public class DynamicType2 : IDynamicMetaObjectProvider
    {
        public DynamicMetaObject GetMetaObject(Expression parameter)
        {
            Console.WriteLine("开始获得元数据......");
            return new Metadynamic(parameter, this);
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            dynamic dynamicobj2 = new DynamicType2();
            dynamicobj2.Call();
            Console.Read();
        }
    }
    开始获得元数据......
    Call方法被调用了

     

    展开全文
  • 静态类型与动态类型

    千次阅读 多人点赞 2015-06-18 10:05:50
    静态类型 & 动态类型

    以下文章系转载,慎重使用,尊重作者
    转载地址:http://www.oschina.net/question/54100_20313

    为了支持c++的多态性,才用了动态绑定和静态绑定。理解他们的区别有助于更好的理解多态性,以及在编程的过程中避免犯错误,需要理解四个名词:
    1、对象的静态类型:对象在声明时采用的类型。是在编译期确定的
    2、对象的动态类型:目前所指对象的类型。是在运行期决定的

    对象的动态类型可以更改,但是静态类型无法更改。关于对象的静态类型和动态类型,看一个示例:

    class B
    {
    };
    
    class C : public B
    {
    };
    
    class D : public B
    {
    };
    // pD的静态类型是它声明的类型D*,动态类型也是D*
    D* pD = new D();  
    
    // pB的静态类型是它声明的类型B*,动态类型是pB所指向的对象pD的类型D*                          
    B* pB = pD;   
    
     C* pC = new C();
     //pB的动态类型是可以更改的,现在它的动态类型是C* 
     pB = pC;  

    3、静态绑定:绑定的是对象的静态类型,某特性(比如函数)依赖于对象的静态类型,发生在编译期。

    4、动态绑定:绑定的是对象的动态类型,某特性(比如函数)依赖于对象的动态类型,发生在运行期。

    class B
    {
        void DoSomething();
        virtual void vfun();
    }
    
    class C : public B
    {
        void DoSomething()
        virtual void vfun();
    }
    
    class D : public B
    {
        void DoSomething();
        virtual void vfun();
    }
    
    D* pD = new D();
    B* pB = pD;

    让我们看一下, pD->DoSomething() 和 pB->DoSomething() 调用的是同 一个函数吗?
    不是的,虽然 pD 和 pB 都指向同一个对象。因为函数 DoSomething 是一个no-virtual 函数,它是静态绑定的,也就是编译器会在编译期根据对象的静态类型来选择函数。pD 的静态类型是 D*,那么编译器在处理 pD->DoSomething() 的时候会将它指向 D::DoSomething()。同理,pB 的静态类型是 B*,那 pB->DoSomething() 调用的就是 B::DoSomething()。

    让我们再来看一下,pD->vfun() 和 pB->vfun() 调用的是同一个函数吗?
    是的。因为vfun是一个虚函数,它动态绑定的,也就是说它绑定的是对象的动态类型,pB和pD虽然静态类型不同,但是他们同时指向一个对象,他们的动态类型是相同的,都是D*,所以,他们的调用的是同一个函数:D::vfun()。

    上面都是针对对象指针的情况,对于引用(reference)的情况同样适用。

    指针和引用的动态类型和静态类型可能会不一致,但是对象的动态类型和静态类型是一致的。
    D D;
    D.DoSomething()和D.vfun()永远调用的都是D::DoSomething()和D::vfun()。

    至于哪些是动态绑定,哪些是静态绑定,有篇文章总结的非常好:
    我总结了一句话:只有虚函数才使用的是动态绑定,其他的全部是静态绑定。目前我还没有发现不适用这句话的,如果有错误,希望你可以指出来。(ps:原作者说的)

    特别需要注意的地方
    当缺省参数和虚函数一起出现的时候情况有点复杂,极易出错。我们知道,虚函数是动态绑定的,但是为了执行效率,缺省参数是静态绑定的

    class B
    {
     virtual void vfun(int i = 10);
    }
    class D : public B
    {
     virtual void vfun(int i = 20);
    }
    D* pD = new D();
    B* pB = pD;
    pD->vfun();
    pB->vfun();

    由上面的分析可知 pD->vfun() 和 pB->vfun() 调用都是函数 D::vfun(),但是他们的缺省参数是多少?
    分析一下,缺省参数是静态绑定的,pD->vfun()时,pD 的静态类型是 D*,所以它的缺省参数应该是 20;同理,pB->vfun() 的缺省参数应该是 10。编写代码验证了一下,正确。
    对于这个特性,估计没有人会喜欢。所以,永远记住:
    绝不重新定义继承而来的缺省参数(Never redefine function’s inherited default parameters value.)”

    展开全文
  • 编程语言一般分为动态类型、静态类型和强类型、弱类型,例如Java是静态、强类型编程语言,而JavaScript是动态、弱类型编程语言。 一、动态类型与静态类型 动态类型语言是运行期间才做数据类型检查的语言,...

    编程语言一般分为动态类型、静态类型和强类型、弱类型,例如Java是静态、强类型编程语言,而JavaScript是动态、弱类型编程语言。

    一、动态类型与静态类型

    动态类型语言

    运行期间才做数据类型检查的语言,即动态类型语言编程时,永远不用给任何变量指定数据类型。该语言会在第一次赋值给变量时,在内部将数据类型记录下来。例如:JavaScript、Python、PHP。

    优点:方便阅读,不需要写非常多的类型相关的代码;

    缺点:不方便调试,命名不规范时会造成读不懂,不利于理解等。

    静态类型语言

    编译期间做检查数据类型的语言,即写程序时要声明所有变量的数据类型,是固定的。使用数据之前,必须先声明数据类型(int ,float,double等)。相当于使用之前,首先要为它们分配好内存空间。

    例如:C/C++是静态类型语言的典型代表,其他的静态类型语言还有C#、JAVA等。

    优点:结构非常规范,便于调试,方便类型安全

    缺点:为此需要写更多类型相关代码,较复杂。

    二、强类型与弱类型

    强类型

    指的是程序中表达的任何对象所从属的类型都必须能在编译时刻确定。强类型是针对类型检查的严格程度而言的,它指任何变量在使用的时候必须要指定这个变量的类型,而且在程序的运行过程中这个变量只能存储这个类型的数据。因此,对于强类型语言,一个变量不经过强制转换,它永远是这个数据类型,不允许隐式的类型转换。例如:假设定义了一个double类型变量a,不经过强制类型转换那么程序int b = a是无法通过编译。常用的强类型语言有Java、C# 、Apex和Python等。

    强类型的优点:
    1、编译时刻能检查出错误的类型匹配,以提高程序的安全性;
    2、可以根据对象类型优化相应运算,以提高目标代码的质量;
    3、减少运行时刻的开销。

    弱类型

    正好与强类型相反,编译时的检查很弱,它仅能区分指令和数据,弱类型语言允许变量类型的隐式转换,允许强制类型转换等,如字符串和数值可以自动转化。

    二者区别:

    1、不管是强类型还是弱类型,变量都有两个属性:类型和值;即弱类型的变量同样有类型。不管是哪一种编程语言,其中使用的变量,都既有类型,又有值。强类型的变量类型,必须在源代码中明确定义,称之为“变量声明”,弱类型的变量类型则是无需声明的,由解释器解释。但是,这并不意味着,弱类型的变量就没有类型这一概念了。

    2、强类型的变量类型是不能改变的,弱类型变量是随需改变的,这是强弱的真正含义。 强类型的变量一经声明,就只能存储这种类型的值,其他的值则必须通过转换之后才能赋给该变量,有编译器自动理解的转换,也有由程序员明确指定的强制转换。但是,弱类型的变量类型则是随着需要不断转换。

    3、强制转换并没有改变变量类型。强类型语言有个“强制转换”,这改变的是变量的值的类型,以便进行赋值,而没有改变变量的类型。变量的类型是不允许改变的。

    展开全文
  • C++动态类型与静态类型

    千次阅读 多人点赞 2017-07-21 15:00:45
    大多数情况下对象的静态类型和动态类型相同,我们不用关系二者区别;只有多态情况下,即在有虚函数的继承体系中,通过基类的指针或引用调用虚函数时,这时我们就需要关系指针或引用对象的动态类型,因为它们的静态...

    一、前言

        其实关于C++的动态绑定就足以写好多篇博客了,但在这篇文章中我不准备深刻剖析C++动态绑定机制(即虚函数机制),只是说明动态绑定和静态绑定的区别,强调C++对象的动态类型和静态类型。


    二、静态类型与动态类型

        什么是静态类型?什么是动态类型?首先这两种肯定是对象(变量)类型的一种说法,而区分这两种类型最直接的方法就是看表达式的形式。关于一个表达式的对象(变量)的静态类型和动态类型需要从两点进行分析:

            (1)该对象(变量)的静态类型和动态类型是否相等;

            (2)如果该对象的静态类型和动态类型不相等,其动态类型是否有作用。

    对于第(1)点,其实我们可以认为每个对象(变量)都存在动态类型和静态类型,只是大多数情况下一个对象的动态类型和静态类型是相等的,所以我们平常都没有强化这两个概念,如表达式int a; 对象a的静态类型和动态类型就是相等的,所以平常我们都是直接称呼变量a的类型是int。对于第(2)点,首先只有当我们的表达式使用的是指针或引用时对象的静态类型和动态类型才有可能不同,而且就算一个对象的静态类型和动态类型不相等,其还不一定能享受到动态类型所带来的方便(即动态绑定),因为我们知道,动态绑定的前提条件是继承体系中的子类继承并重写了基类的虚函数。

        如果觉得上面的解释有点绕,直接解释静态类型和动态类型的定义,一个对象(变量)的静态类型就是其声明类型,如表达式int a中的int就是对象a的声明类型,即静态类型;而一个对象(变量)的动态类型就是指程序执行过程中对象(指针或引用)实际所指对象的类型,如Base* pB = new Drived; 其中class Drived继承于class Base,则指针对象pB的静态类型就是Base(声明类型),动态类型就是Drived(实际所指对象的类型),又如Base* pB = new Base;此时指针对象pB的静态类型和动态类型也是相等的,都是Base。


    三、动态类型的作用

        上面已经说明了,大多数情况下一个对象的静态类型和动态类型都是相等的,而且就算其静态类型和动态类型不相等,也不一定会使动态类型发挥威力,那到底什么时候一个对象(变量)的动态类型能发挥其威力呢?三个条件:(1)该对象是指针或引用形式;(2)该对象的静态与动态类型不同;(3)应用场景为带虚函数的继承体系结构。其实你可以直接理解为:动态类型就是为动态绑定(C++继承的多态)准备的。只有当上述3个条件都满足了,动态类型才能发挥其威力,即很好的支持虚函数动态绑定机制,为什么呢?这与C++编译器对多态继承结构中的成员函数调用机制有关。

        假设有以下继承结构:class Drived : public Base,然后有表达式p->mem()或obj.mem(),其中mem()是一个类成员函数,但具体是基类还是子类,现在可以不用管,而且我们也不用管p或者obj是指向哪个类。当程序的编译期,当编译器遇到表达式p->mem()或obj.mem(),执行以下步骤:

            (1)首先确定p(或obj)的静态类型,即声明类型;

            (2)然后在p(或obj)的静态类型中查找mem()函数,如果没有找到,按照作用域规则,这时编译器会到其直接基类中寻找,并依次向上,直到达到继承链的顶端,如果在这个过程中找到了,则继续下一步,如果没有找到,则报错;

            (3)一旦找到名字匹配的mem()函数,则编译器会根据mem()是否是虚函数,以及我们是通过指针或引用(如p)来调用mem()函数,还是通过类对象(如obj)来调用mem()函数,生成不同的代码。如果mem()是虚函数且是通过指针或引用调用(如p->mem()),编译器生成的代码会检查其动态类型,这就是动态绑定的过程,也就是说编译器生成的代码会直到运行期确定了动态类型才决定具体调用基类还是子类的虚函数mem();如果mem()不是虚函数且是通过对象调用(如obj.mem()),则编译器会产生一个常规的函数调用代码,可以直接确定调用哪一个mem()函数。


    四、总结

        对上面的介绍进行总结:大多数情况下对象的静态类型和动态类型相同,我们不用关系二者区别;只有多态情况下,即在有虚函数的继承体系中,通过基类的指针或引用调用虚函数时,这时我们就需要关系指针或引用对象的动态类型,因为它们的静态类型毋庸置疑是基类,但动态类型有可能是子类(其实也不是有可能,要想应用多态,其动态类型必须是子类),所以动态类型就是跟虚函数、多态、动态绑定息息相关的。

    展开全文
  • C# 动态类型与动态编译简介

    千次阅读 2018-11-29 22:12:55
    C# 动态类型与动态编译简介动态类型动态编译CSScript 关于C#的动态类型与动态编译的简介,主要是一个Demo。 动态类型 关键字: dynamic 这里有详细的介绍:[C#基础知识系列]专题十七:深入理解动态类型 动态类型...
  • (1)动态类型语言:动态类型语言是指在运行期间才去做数据类型检查的语言,也就是说,在用动态类型的语言编程时,永远也不用给任何变量指定数据类型,该语言会在你第一次赋值给变量时,在内部将数据类型记录下来。...
  • 动态类型语言&动态语言

    千次阅读 2017-11-18 18:56:34
    动态语言 动态类型语言首先,这是两个不同的概念动态语言 dynamic programming language程序运行时,允许改变程序结构(例如引进新函数、删除旧函数)或变量类型。 从这个观点来看,Perl、Python、Ruby是动态语言,...
  • 动态类型 类型断言与type-switch 全部代码 截图 参考 动态类型 我们知道Go不像Python,变量可以没有类型。那么如果一个函数的参数需要兼容多个类型或是需要判断变量类型该如何做呢? 我们可以使用接口,上一...
  • 动态类型语言和静态类型语言

    千次阅读 2018-05-24 15:54:33
    https://www.cnblogs.com/liuning8023/p/4286044.html  动态类型语言和静态类型语言本文主要说明动态类型语言和静态类型语言。类型检查所进行的检验处理以及实行类型的约束,可发生在编译时期(静态检查)或运行...
  • iOS动态类型和动态绑定

    千次阅读 2015-08-20 11:16:04
    IOS的动态性主要来自以下方面的特性:动态类型,动态绑定,动态载入,SEL类型。 1,IOS的动态类型(强类型)id可以在代码运行时判断对象的类型。使用id类型(又称强类型)可以在运行的时候使用任何数据类型来替换。动态类型...
  • 深入理解动态类型

    千次阅读 2017-07-11 23:38:05
    动态类型介绍 为什么需要动态类型 动态类型的使用 动态类型背后的故事 动态类型的约束 实现动态行为 总结 引言:  终于迎来了我们C# 4中特性了,C# 4主要有两方面的改善——Com 互操作性的改进和动态类型的...
  • 静态类型和动态类型有什么区别?

    千次阅读 2019-07-01 14:30:25
    编程语言按照类型检查可以分为两大类:**静态类型 (Static Typing) **和 动态类型 (Dynamic Typing)。在现在比较流行的这些语言里,静态类型的代表人物有 Java、C/C++、Golang 等,动态类型有 Python、Ruby 等。 ...
  • java静态类型与动态类型

    千次阅读 2017-06-13 09:51:13
    动态类型检查:在程序运行期间验证类型安全的过程; Java使用静态类型检查在编译期间分析程序,确保没有类型错误。基本的思想是不要让类型错误在运行期间发生。class A { A me() { return this; } public void ...
  • Python是静态还是动态类型?是强类型还是弱类型? Python是动态的强类型语言 动态还是静态指的是编译期还是运行期确定类型 强类型指的是不会发生隐式类型转换 为什么要用Python? 胶水语言,轮子多,应用广泛 ...
  • 由于继承导致对象的指针和引用具有两种不同的类型:静态类型和动态类型。静态类型:指针或者是引用声明时的类型。动态类型:由实际指向的类型确定。GameObject *pgo = new SpaceShip // pgo 静态类型是 GameObject*...
  • 强类型:偏向于不容忍隐式类型转换。譬如说haskell的int就不能...动态类型:编译的时候不知道每一个变量的类型,因为类型错误而不能做的事情是运行时错误。譬如说你不能对一个数字a写a[10]当数组用。 弱类型: ...
  • 静态类型和动态类型检查

    千次阅读 2015-11-06 10:38:17
    1、静态类型和动态类型 如果大家希望学好C++的话那请务必多学习一下c++内部的对象模型,前面有很多博客都是关于这方面的不过都不是自己写的(因为自己很懒)。 举个例子:类A,类B,如果B没有继承A那这就没...
  • 静态类型和动态类型的区别编译型语言解释型语言混合型语言静态类型语言动态类型语言 编译型语言 源代码需要通过编译器编译成机器可识别的机器码,包括编译和链接两个过程。不同操作系统下的可执行文件不一样。代表...
  • 动态类型语言&静态类型语言

    千次阅读 2017-04-14 16:41:56
    1.动态类型语言概念:意思就是类型的检查是在运行时做的表现:使用变量前不需要声明变量举例:JavaScript、Ruby、Python这些都属于动态类型语言2.静态类型语言概念:意思就是类型判断是在运行前做的(如编译阶段)...
  • C++ 对象的静态类型与动态类型

    千次阅读 2014-12-04 14:19:10
    继承导致对象的指针和引用具有两种不同的类型: 静态类型 和 动态类型 。 静态类型 :指针或者是引用声明时的类型。 动态类型 :由他实际指向的类型确定。   class Base {   } class Derived:public ...
  • java虚拟机动态类型语言支持

    千次阅读 2017-08-30 18:59:34
    这篇博客是根据《深入理解java虚拟机》的讲解和本人对动态类型语言的一些认识,来深度剖析一下java虚拟机对动态类型语言的支持!
  • 编译型语言要先编译再运行,而解释性语言直接“运行”源代码。 Python是种强类型的语言。 有人可能会问,在python中,...动态类型语言是一种在运行期间才去确定数据类型的语言,与静态类型相反。 VBScript 和 Pyt...
  • 概念区别 【编译型语言与解释型语言、动态类型语言与静态类型语言、强类型语言与弱类型语言】 文章目录一、编译型语言与解释型语言二、动态类型语言与静态类型语言三、强类型语言与弱类型语言总结 一、编译型语言与...
  • 一、Objective-C多态 1.概念:相同接口,不同的实现 ...2.Objective-C不同于传统程序设计语言,它可以再运行时加入新的数据类型和新的程序模块:动态类型识别,动态绑定,动态加载 3.id类型:通用指
  • C#中的动态类型dynamic

    千次阅读 2019-07-02 10:37:34
    1,动态类型dynamic最常见啊的使用就是在将json字符串接受下来,然后像操作是js操作json一样去处理数据,很轻盈的!废话不多说,上代码! var info = "{\"Account\":\"张三\",\"Pwd\":\"12323\"}"; //json字符串 ...
  • 动态类型(dynamic typing)是Python另一个重要的核心概念。我们之前说过,Python的变量(variable)不需要声明,而在赋值时,变量可以重新赋值为任意值。这些都与动态类型的概念相关。   动态类型  在我们接触的对象...
  • 通常我们所说的动态语言、静态语言指 动态类型语言(Dynamically Typed Language)和 静态类型语言Statically Typed Language)。 还有一个 Dynamic Programming Language (动态编程语言),静态编程语言。 动态...
  • C++3种动态类型识别的方法

    千次阅读 2018-08-11 15:56:38
    一,什么是动态类型 基类指针所指对象的实际类型 基类指针是否可以强制类型转换为子类指针取决于动态类型! 二,方法 1,利用多态 必须从基类开始提供类型虚函数 所有的派生类都必须重写类型虚函数 每个派生...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,529
精华内容 31,411
关键字:

动态类型