精华内容
下载资源
问答
  • 面向对象多态理解

    2019-10-01 13:11:34
    多态 (polymorphism) 一最初来源于希腊语 polumorphos,含义是具有多种形式或形态情形。在程序设计领域,一广泛认可定义是“一种将不同特殊行为和单个泛化记号相关联能力”。然而在人们直观感觉中,...

    一、多态的概念

    多态 (polymorphism) 一词最初来源于希腊语 polumorphos,含义是具有多种形式或形态的情形。在程序设计领域,一个广泛认可的定义是“一种将不同的特殊行为和单个泛化记号相关联的能力”。然而在人们的直观感觉中,多态的含义大约等同于“同一个方法对于不同类型的输入参数均能做出正确的处理过程,并给出人们所期望获得的结果”,也许这正体现了人们对于多态性所能达到的效果所寄予的期望:使程序能够做到越来越智能化,越来越易于使用,越来越能够使设计者透过形形色色的表象看到代码所要触及到的问题本质。

    二、多态的分类

    总体是分为通用多态和专用多态:

    通用多态:不同的类型值,执行相同的代码。

    专用多态:不同的类型值,执行不同的代码。(类似枚举 “什么类型,执行什么操作”)

    通用多态分为:参数多态和包含多态

    参数多态:参考c++中的template(静态联编时候实现)

    包含多态:可以理解为abstract functions,interface的方法(动态联编时候实现,)

    专用多态:强制多态和重载多态

    强制多态:可以理解为类型的隐式转换(静态联编时候实现)

    重载多态:参考C++中的函数重载的理解(静态联编时候实现)

    2.1 参数多态

    概念:采用参数化模板,通过给出不同的类型实参,使得一个结构有多种类型。

    • 从C++的模板结构可以看出:
      对实参所取的类型不加限制;
      对不同的实参执行的是相同的代码。
    • 在一个抽象结构中允许以参量形式来表示可变的类型、函
      数、常数、数据值,在编译时(静态)进行实例化,结果
      是一个具体的结构(类型、函数等)。

    2.2 包含多态

    概念:同样的操作可用于一个类型及其子类型。

          例:Pascal  中的子界。子类型:a value of a subtype can be used everywhere a value of the supertype can be expected.
          注意:子类型与将来要介绍的子类是有区别的。包含多态一般需要进行运行时的类型检查。

    2.3 过载多态

    概念:同一个名(操作符、函数名)在不同的上下文中有不同的类型。

          程序设计语言中基本类型的大多数操作符都是过载多态的。

    2.4 强制多态

    概念:编译程序通过语义操作,把操作对象的类型强行加以变换,以符合函数或操作符的要求。

    • 程序设计语言中基本类型的大多数操作符,在发生不同类型的数据进行混合运算时,编译程序一般都会进行强制多态。
    • 程序员也可以显式地进行强制多态的操作(Casting)。

    三、C语言一条语句实现四种多态

    老师要求我们用C语言的一条语句实现四种多态,想了半天,只能这样写了,下面是代码,可能理解上有出入,包含多态的语句不太确定的是。

    #include <stdio.h>
    enum dataType 
     { 
        INT, 
        DOUBLE, 
        CHAR, 
     }; 
    int f(void *a,int dataType){//这里实现了参数多态的函数!
        switch (dataType){
        case 1:
            {
            int x=*(int*)a;
            break;
            }
        case 2:
            {
            char x=*(char*)a;
            break;
            }
        case 3:
            {
             double x=*(double*)a;
            break;
            }
        }
        return 0;
    }
    void main (){
        int i=1;
        double j=2.0;
        float  a=3.0,b=4.0;//double的子类型
        double c=5.0,d=6.0;
        printf("参数多态%d,%d\n包含多态%lf,%lf\n过载多态%f,%lf\n强制多态%lf\n",sizeof(int),c*d,a*b,(1+2),(1.0+2.0),1);
        //本条语句分别实现了参数、包含、过载、强制多态
    }

          这里要讲的是参数多态,虽然觉得实现起来用处不大,但是至少C可以实现。主要用到的是void,几乎所有讲授 C 语言课程的老师都会告诉你:“指针是整个 C 语言的精髓所在。”而你也一直敬畏着指针,又爱又恨地使用着它。许多教材都告诉你,int * 叫做指向整型的指针,而 char * 是指向字符型的指针,等等不一而足。然而这里有一个另类的指针家族成员—— void *。不要按照通常的命名方式叫它做指向 void 类型的指针,它的正式的名字叫做:可以指向任意类型的指针。你一定注意到了“任意类型”这四个字,没错,实现多态,我们靠的就是它。

         在其他网站上看到一个C语言实现的参数多态,可以借鉴,地址是http://www.ibm.com/developerworks/cn/linux/l-cn-cpolym/

         这里就先写到这里,有机会再补充~ 

    转载于:https://www.cnblogs.com/pang1567/p/3358273.html

    展开全文
  • 这个过程在本文中被称为 DOM 标识 “序列化”。而下次用户访问时,又可以从后端取回,然后“反序列化”为对应 DOM 节点。 有几种常见方式来标识 DOM 节点: <ul><li>使用 xPath</li><li>...
  • 是MFC小组早期代号,AFX,当时是指 applecation freamwork ,如果你程序用到了MFC,那这个头文件是一定要包含。Microsoft程序员开始试图将C++...他们把这个应用程序框架叫做AFX(AFX这个词来源于Application Fram

    是MFC小组早期的代号,AFX,当时是指   applecation   freamwork   ,如果你的程序用到了MFC,那这个头文件是一定要包含的。

    Microsoft的程序员开始试图将C++和面向对象的编程概念应用于Windows编程中,经编写出一个可以使windows编程工作更加简便的应用程序框架。他们把这个应用程序框架叫做AFX(AFX这个词来源于Application   FrameWork,但奇怪的是这个词组中并没有包含"X"这个字母)。直到今天,AFX小组早已不存在了,AFX这个名称也于1994年初不再使用,但在Visual   C++和MFC中,AFX的影子却随处可见,很多全局函数、结构和宏的标识符都被加上了AFX的前缀。  

    关于afx这个词的意思tasehouny(阿甘)说的是对的     afx.h是VC里的预编译头,比如说你有十个CPP文件     每个都include了windows.h,结果windows.h就会被编译十次     要知道windows.h是很大的,编译起来很慢     这个时候你就可以在afx.h里加一句#include   <windows.h>     然后afx.h连同里面所有的include会被编译成一个PCH文件     这样编译十个CPP的时候都直接拿这个PCH文件来用     不用重复编译了,速度提高很多         如果你在建立项目的时候选了预编译头支持(缺省是有),     就必须在每个CPP的第一行加上#include   "afx.h"

    在九十年代初的时候OO被炒得很热,许多人以为OO是无所不能的     微软也这么认为,所以他们想搞出一套类库来封装全部的OS特性     使得程序可以在WINDOWS   OS/2   X等等任何的GUI系统上运行     结果可想而知,这个东西当然是没做出来     到94年微软放弃了AFX,把AFX中已经完工的部分做了一点改进     形成了MFC     至今MFC还有LINUX版本,也算是AFX计划的一点残留吧

    展开全文
  • 我觉得这里 unobtrusive 所要强调是 Vue 数据模型仅仅是普通 JavaScript 对象这一特点,以区别于其他框架特殊数据模型。所以我觉得 unobtrusive 所要表达内容类似于“侵入性比较低“之类意思...
  • 在计算机科学中,这个词有特别定义,依据 Free Online Dictionary of Computing网站解释: 一个变量,它在可能指向一个对象,这个对象的类在编译时还未知,但是会在运行时根据实际指向类执行相应反馈。 ...

    1.多态性(Polymorphism)

    关于多态的普通定义来源于它的希腊词根 –  “Poly” 表示很多, “Morph” 表示形式。

    在计算机科学中,这个词有特别的定义,依据 Free Online Dictionary of Computing网站的解释:

    一个变量,它在可能指向一个对象,这个对象的类在编译时还未知,但是会在运行时根据实际指向的类执行相应的反馈。

    这些定义最终可以归结为“一个对象同时可以成为不同的事物”。

    Objective-C 中的多态性有一些子类型,但是其中最主要的两种类型,也是最常见的两种就是修饰模式适配器模式


    修饰(Decorator)模式

    苹果公司的基础文档 Cocoa 设计模式中有这样的解释:

    修饰设计模式将额外的职责动态的附加给一个对象。修饰模式为用于拓展功能性的子类化提供了灵活的选择。就像子类化一样,修饰模式能让你不用修改原来的代码就能合并添加新的功能。 修饰类包含了一个被拓展行为类的对象。 

    在Objective-C中,一个修饰模式的最典型例子就是类别的使用。

    类别是iOS中一种特别的类,它能让你在不继承一个类,也不需要修改这个类的源代码的情况下为这个类添加额外你所需要的方法。它主要被用来拓展iOS自带的UIKit组件。

    类别与子类之间的区别非常的简单:类别能让你为一个存在的类添加新的方法,但是你不能修改已经存在的方法。你不能为一个类别添加新的特性或者实例变量 – 你只能使用那些本来就存在的。如果你想添加新的特性或者实例变量,那你就要考虑使用继承来创建一个子类,并添加你想要添加的特性和方法了。

    但是如果你不需要这样做呢?假如你只是需要将你经常使用的一些方法封装进UIKit对象呢?在这种情况下,类别就是你的最佳解决方案。


    适配器(Adapter)模式

    再看苹果文档中的解释 Cocoa Fundamentals Guide:

    适配器设计模式将一个类的接口转变为另外一种用户期望的接口。适配器让那些因为接口不适配而冲突的类能够一起工作。对目标对象的类实现了解耦。

    协议是 Objective-C 中适配器的最主要的例子。它可以指定一些能被任何类所实现的方法。它们通常被用于  DataSource 和 Delegate 方法,但是也可以用于帮助两个完全不相关类之间的通信。

    这种模式的优势在于只需要某个类声明它遵从这个协议,无论这个类是个模型或者视图又或是控制器都没关系。它只想知道在另外一个类里所发生的事,并为此实现所有需要的方法。

    为了知道用户希望车所应转弯的角度,你就需要利用 UIAlertViewDelegate 协议以获取用户输入UIAlertView的数据。



    2.类工厂方法

    类工厂的主要理念在于产生并返回一个特定类的实例对象,并在产生对象时尽可能的预填充数据。相比调用 alloc/init 再设置特性,使用类工厂的一个显而易见的好处就是,你的代码将会缩短很多。

    这样,你就能使用一个方法来创建一个对象并初始化它的所有特性,而不需要用一个方法来创建对象,再用很多行代码来设置各种特性。与此同时,这种技术还有两个不太明显的好处。

    其一,它强制了每个使用你的类的人必须提供你所需要的每一项数据,以创建一个功能完整的实例对象。鉴于你在本教程的前面部分所创建的那些对象,你可能也发现了,往往很容易就忘记了一个或两个特性的初始化。有了类工厂方法, 你将被强制关注你创建对象所需要的每一项特性。

    其二,公认的减少了使用了 ARC 的代码将产生的问题,在 iOS 5之后类工厂方法将返回自动释放池对象,释放调用者而不必在以后再释放。你可能不需要担心这个问题,除非你需要兼容老的代码,但是这依旧是一个值得注意的问题。

    展开全文
  • Thunk 技术改进

    2012-03-31 17:42:30
    Thunk 技术的一个改进 作者:南风 下载源代码 摘要:介绍了 thunk 技术中如何避免直接写...《深度探索C++对象模型》中对这个词的来源有过考证(在中文版的162页),说thunk是knuth的倒拼字。knuth就是大名鼎鼎的计算机

    Thunk 技术的一个改进

    作者:南风

    下载源代码

    摘要:介绍了 thunk 技术中如何避免直接写机器码。

    关键字:Thunk  机器码 this指针

      Thunk技术,一般认为是在程序中直接构造出可执行代码的技术(在正常情况下,这是编译器的任务)。《深度探索C++对象模型》中对这个词的来源有过考证(在中文版的162页),说thunk是knuth的倒拼字。knuth就是大名鼎鼎的计算机经典名著《The Art of Computer Programming》的作者,该书被程序员们称为“编程圣经”,与牛顿的“自然哲学的数学原理”等一起,被评为“世界历史上最伟大的十种科学著作”之一(也不知是谁评的,我没查到,不过反正这本书很牛就是了)。
      一般情况下,使用thunk技术都是事先查好指令的机器码,然后将数组或结构体赋值为这些机器码的二进制值,最后再跳转到数组或结构体的首地址。比如在参考文献[1]中的代码:

    void foo(int a)
    { printf ("In foo, a = %d\n", a); }
    
    unsigned char code[9];
    * ((DWORD *) &code[0]) = 0x042444FF; /* inc dword ptr [esp+4] */
                  code[4]  = 0xe9;       /* JMP */
    * ((DWORD *) &code[5]) = (DWORD) &foo - (DWORD) &code[0] - 9; /* 跳转偏移量 */
    
    void (*pf)(int/* a*/) = (void (*)(int)) &code[0];
    pf (6);
    

      这是一段典型的thunk代码,其执行结果是“In foo, a = 7”。
    可以看到,它定义了一个数组code[9],然后将事先查好的各汇编指令的机器码直接赋值给数组。然后定义一个函数指针等于数组的首地址,最后通过该函数指针调用thunk代码。这里使用了函数指针完成调用,好处是代码比较清晰易读。也可以使用汇编代码jmp或call来完成,这样就不必额外定义一个函数指针。
      网络上的thunk代码,基本上都是这个思路。如果你实际写一段这样的代码,一定会发现很麻烦。对着教科书查找每一个汇编指令的机器码,相信不会是一件愉快的事情。其实我们回过头来想想,这件事计算机来做不是最合适吗,编译器不就是做这个事情的吗?
      以上面的代码为例,让我们重新考虑一下整个过程。我们的目的是在调用函数foo之前将参数增加1。一般而言,这样做肯定是没有foo函数的源代码或者不允许修改源代码,否则直接改foo函数的代码就好了,何必这么麻烦。为了调用时候的简单化,定义一个函数指针是比较合适的,否则每次调用都写汇编代码jmp或call太麻烦。这样一来,函数指针必须指向一个代码段的地址。但是这个代码段必须用机器码来构造吗,直接写汇编代码也同样可以做到。
      当然,这里有一个问题。我们写汇编指令的时候,必须是一条指令一条指令的写,不能说指令写一半,然后让汇编程序去处理。上面的代码中,第一条指令inc直接写汇编语句当然没问题。但下面的jmp语句,就不能直接写。因为我们写汇编语句的时候,jmp跳转偏移量是未知的,必须编译后才知道。并且我们不能只写jmp而不写偏移量,那是通不过编译的。
      这个问题可以这样解决,写jmp语句的时候,我们写一个占位的DWORD,其值设为一个特殊的值,比如0xffff(原理是这样,实际处理还要迂回一下,后面有说明)。只要在这段thunk代码中不出现这个值就好。然后执行的时候,在第一次调用之前,在thunk代码中查找该值,将其替换为计算出来的动态值。经过这样的处理,就可以彻底在thunk代码中消除机器码的直接操作。
      更一般化,为了生成正确的机器码,我们用两个函数。一个用于生成机器码的模板,另一个函数用于在机器码的模板中填入需要动态计算产生的值。下面是一个例子:

    void ThunkTemplate(DWORD& addr1,DWORD& addr2)//生成机器码
    {
    	int flag = 0;
    	DWORD x1,x2;
    
    	if(flag)
    	{
              //注意,这个括号中的代码无法直接执行,因为其中可能含有无意义的占位数。
    		__asm
    		{
    thunk_begin:
                       ;//这里写thunk代码的汇编语句. 
                       ...
    	
    thunk_end:   ;
    		}
    	}
    	__asm
    	{
    		mov   x1,offset thunk_begin; //取 Thunk代码段 的地址范围.
    		mov   x2,offset thunk_end;
    	}
    
        addr1 = x1;
        addr2 = x2;
    }
    

      上面的函数用于生成thunk的机器码模板,之所以称为模板,是因为其中包含了无意义的占位数,必须将这些占位数替换为有意义的值之后,才可以执行这些代码。因此,在函数中thunk代码模板放在一个if(0)语句中,就是避免调用该函数的时候执行thunk代码。另外,为了能方便的得到thunk代码模板的地址,这里采用一个函数传出thunk代码的首尾地址。

    至于替换占位数的功能是很简单的,直接替换就好。

    void ReplaceCodeBuf(BYTE *code,int len, DWORD old,DWORD x)//完成动态值的替换.
    {
    	int i=0;
    
    	for(i=0;i<len-4;++i)
    	{
    		if(*((DWORD *)&code[i])==old)
    		{
    			*((DWORD *)&code[i]) = x;
    
    			return ;
    		}
    	}
    }
    
    这样使用两个函数:
    	DWORD addr1,addr2;
    	ThunkTemplate(addr1,addr2);
    
    	memset(m_thunk,0,100);//m_thunk是一个数组: char m_thunk[100];
    	memcpy(m_thunk,(void*)addr1,addr2-addr1);//将代码拷贝到m_thunk中。
    
    	ReplaceCodeBuf(m_thunk,addr2-addr1,-1,(DWORD)((void*)this));//将m_thunk中的-1替换为this指针的值。
    

      原理部分到此为止。下面举一个完整的,有实际意义的例子。在windows中,回调函数的使用是很常见的。比如窗口过程,又比如定时器回调函数。这些函数,你写好代码,但是却从不直接调用。相反,你把函数地址传递给系统,当系统检测到某些事件发生的时候,系统来调用这些函数。这样当然很好,不过如果你想做一个封装,将所有相关部分写成一个类,那问题就来了。
      问题是,这些回调函数的形式事先已经定义好了,你无法让一个类的成员函数成为一个回调函数,因为类型不可能匹配。这不能怪微软,微软不可能将回调函数定义为一个类成员函数(该定义为什么类?),而只能将回调函数定义为一个全局的函数。并且微软其实很多时候也提供了补救措施,在回调函数中增加了一个void *的参数。这个参数一般都用来传递类的this指针。这样一来,可以这样解决:给系统提供一个全局函数作为回调函数,在该函数中通过额外的那个void *参数访问到类的对象,从而直接调用到类成员函数。如此,你的封装一样可以完成,不过多了一次函数调用而已。

    但是,不是所有的回调函数都这么幸运,微软都给它们提供了一个额外的参数。比如,定时器的回调函数就没有。

    VOID CALLBACK TimerProc(
      HWND hwnd,         // handle to window
      UINT uMsg,         // WM_TIMER message
      UINT_PTR idEvent,  // timer identifier
      DWORD dwTime       // current system time
    );
    

    四个参数,个个都有用途。没有地方可以让你传递那个this指针。当然了,你实在要传也可以做到,比如将hwnd设置为一个结构体的指针,其中包含原来的hwnd和一个this指针。在定时器回调函数中取出hwnd后强制转化为结构体指针,取出原来的hwnd,取出this指针。现在就可以通过this指针自由的调用类成员函数了。不过这种方法不是我想要的,我要的是一个通用,统一的解决方法。通过在参数里面加塞夹带的方法,一般也是没有问题的,不过如果碰到一个回调函数没有参数怎么办?另外,本来是封装为一个类的,结果还是要带着一个全局函数,你难道不觉得有些不爽吗?
      这正是thunk技术大显身手的地方了。我们知道,所谓类成员函数,和对应的全局函数,其实就差一个this指针。如果我们在系统调用函数之前正确处理好this指针,那系统就可以正确的调用类成员函数。
      具体的思路是这样的:当系统需要一个回调函数地址的时候,我们传递一个thunk代码段的地址。这个代码段做两件事:

    1、准备好this指针
    2、调用成员函数

    关键的代码如下(完整的工程在附件中):

    void ThunkTemplate(DWORD& addr1,DWORD& addr2,int calltype=0)
    {
    	int flag = 0;
    	DWORD x1,x2;
    
    	if(flag)
    	{
    		__asm //__thiscall
    		{
    thiscall_1:	    mov   ecx,-1;   //-1占位符,运行时将被替换为this指针.
    		    mov   eax,-2;   //-2占位符,运行时将被替换为CTimer::CallBcak的地址.
    		    jmp   eax;
    thiscall_2:  ;
    		}
    
    		__asm //__stdcall
    		{
    stdcall_1:	push  dword ptr [esp]        ; //保存(复制)返回地址到当前栈中
    			mov   dword ptr [esp+4], -1  ; //将this指针送入栈中,即原来的返回地址处
    			mov   eax,  -2;
    	        jmp   eax                    ; //跳转至目标消息处理函数(类成员函数)
    stdcall_2: ;
    		}
    	}
    
    	if(calltype==0)//this_call
    	{
    		__asm
    		{
    			mov   x1,offset thiscall_1;  //取 Thunk代码段 的地址范围.
    			mov   x2,offset thiscall_2 ;
    		}
    	}
    	else
    	{
    		__asm
    		{
    			mov   x1,offset stdcall_1;   
    			mov   x2,offset stdcall_2 ;
    		}
    	}
    
    	addr1 = x1;
    	addr2 = x2;
    }
    

    上面的函数有几个地方需要说明:

    1、为了能适应两种不同的成员函数调用约定,这里写了两份代码。通过参数calltype决定拷贝哪一份代码到缓冲区。
    2、本来一条jmp xxxx;指令这里分解为两条指令:

    mov eax,-2;
    jmp eax;

      这是由汇编语言的特点决定的。直接写jmp -2是通不过的(根据地址的不同,jmp汇编后可能出现好几种形式。这里必须出现一个真实的地址以便汇编器决定jmp类型)。
    3、如果对this指针的知识不清楚,请参考我在vc知识库的另外一篇文章《直接调用类成员函数地址》。

    设置thunk代码的完整代码如下:

    	DWORD FuncAddr;
    	GetMemberFuncAddr_VC6(FuncAddr,&CTimer::CallBcak);
    
    	DWORD addr1,addr2;
    	ThunkTemplate(addr1,addr2,0);
    
    	memset(m_thunk,0,100);
    	memcpy(m_thunk,(void*)addr1,addr2-addr1);
    
    	ReplaceCodeBuf(m_thunk,addr2-addr1,-1,(DWORD)((void*)this)); //将-1替换为this指针.
       	ReplaceCodeBuf(m_thunk,addr2-addr1,-2,FuncAddr); //将-2替换为成员函数的指针.
    

      如果你还想和以前一样直接在数组中赋值机器码(毕竟这样看起来很酷,我完全理解)。那也可以这样,调用ThunkTemplate生成m_thunk后,打印出该数组的值,而后在程序中直接给m_thunk数组赋值,就象网上大部分thunk代码那样,当然在调用前要多一个步骤就是替换掉占位数。不过无论如何,调用这两个函数生成机器码应该比手工查找方便多了,如果你也这样认为,那就算我这篇文章没白写。


    展开全文
  • 来源:https://www.cnblogs.com/xiaohuochai/p/6036475.html1999年,微软公司发布IE5,第一次引入新功能:允许javascript脚本向服务器...2005年2月,ajax这个词第一次正式提出,指围绕这个功能进行开发一整套做法...
  • C++中闭包

    万次阅读 2016-08-04 21:50:49
    这些变量不是在这个代码块内或者任何全局上下文中定义,而是在定义代码块环境中定义(局部变量)。“闭包” 一词来源于以下两者结合:要执行代码块(由于自由变量被包含在代码块中,这些自
  • 一、Mybatis简介 ...MyBatis 本是apache一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。 iBATIS一词来源...
  • 菜鸟词典--什么是REBOL

    2006-07-30 17:52:00
    来源于http://www.jsarmy.com/bbs/archive/index.php?t214.html REBOL 代表基于相关表达式的对象语言(Relative Expression Based Object Language). REBOL 发音为"reb-ol" ,和“rebel with a caus
  • 在一对多关联关系中什么时候应该使用级联的方式呢?...个词的来源是面向对象的分析与设计的技术中产生的。 当一个对象A是由多个其它对象(B,C,D...)组成的,如果当A不存在了,那么B,C,D......
  • VC中AFX意思

    千次阅读 2008-12-03 22:41:00
    AFX是MFC小组早期代号,当时是指 applecation freamwork ,如果你程序用到了MFC,那这个头文件是一定要包含。...他们把这个应用程序框架叫做AFX(AFX这个词来源于Application FrameWork,但奇怪
  • 1.虚拟文件系统中对象的引入 虚拟文件系统这几个字中第一个词是虚拟,这就意味着这样文件系统在磁盘或者其他 ...这个VFS信息都来源于实文件系统,所以VFS必须承载各种 文件系统共有属性 2. ...
  • JS--初窥之闭包理解

    2018-06-14 18:14:10
    “闭包” 一词来源于以下两者结合:要执行代码块(由于自由变量被包含在代码块中,这些自由变量以及它们引用的对象没有被释放)和为自由变量提供绑定计算环境(作用域)。 闭包是一函数内return出来另一...
  • 最近收到一个 issue 期望能在划词的时候同时保存单词的上下文和来源网址。这个功能其实很久之前就想过,但感觉不好实现一直拖延没做。真做完发现其实并不复杂,完整代码在这里,或者继续往下阅读分析。话不多说了,...
  • Java中闭包与回调

    2021-01-21 17:12:32
    这些变量不是在这个代码块或者任何全局上下文中定义,而是在定义代码块环境中定义。“闭包”一词来源于以下两者结合:要执行代码块(由于自由变量存在,相关变量引用没有释放)和为自由变量提供绑定计算...
  • 继承这个词多半用在OOP编程里,比如类继承,但是在Hibernate里表也有继承关系,这也难怪,因为Hibernate目的就是要把数据库对象化。  先来看一个简单例子,一个人员表Person,这张表里主要纪录一些公司人员...
  • AFX是MFC小组早期代号,AFX,当时是指 applecation freamwork ,如果你程序用到了MFC,那这个头文件是一定要包含。 Microsoft程序员开始试图将C++和...他们把这个应用程序框架叫做AFX(AFX这个词来源于Applicati
  • “闭包” 一词来源于以下两者结合:要执行代码块(由于自由变量被包含在代码块中,这些自由变量以及它们引用的对象没有被释放)和为自由变量提供绑定计算环境 (作用域)。在 Scala、Sch...
  • 1 信息熵 熵 (entropy) 这一最初来源于热力学...首先,我们先来理解一下信息这个概念。信息是一个很抽象概念,百度百科将它定义为:指音讯、消息、通讯系统传输和处理的对象,泛指人类社会传播一切内容。那信...
  • 尽管linux支持多达几十种文件系统,但这些真实文件系统并不是一下子都挂在系统中,它们实际上是按需被挂载,老子说有无相生这个VFS信息都来源于实文件系统,所以VFS必须承载各种文件系统共有属性。...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 157
精华内容 62
关键字:

对象这个词的来源