精华内容
下载资源
问答
  • 引入内联函数目的和作用

    千次阅读 2015-10-20 21:45:16
    引入内联函数目的是为了解决程序中函数调用的效率问题。 函数是一种更高级的抽象。它的引入使得编程者只关心函数的功能和使用方 法,而不必关心函数功能的具体实现;函数的引入可以减少程序的目标代码,实 现...

    引入内联函数的目的是为了解决程序中函数调用的效率问题。

    函数是一种更高级的抽象。它的引入使得编程者只关心函数的功能和使用方 法,而不必关心函数功能的具体实现;函数的引入可以减少程序的目标代码,实 现程序代码和数据的共享。但是,函数调用也会带来降低效率的问题,因为调用 函数实际上将程序执行顺序转移到函数所存放在内存中某个地址,将函数的程序 内容执行完后,再返回到转去执行该函数前的地方。这种转移操作要求在转去前 要保护现场并记忆执行的地址,转回后先要恢复现场,并按原来保存地址继续执 行。因此,函数调用要有一定的时间和空间方面的开销,于是将影响其效率。特 别是对于一些函数体代码不是很大,但又频繁地被调用的函数来讲,解决其效率 问题更为重要。引入内联函数实际上就是为了解决这一问题。

    在程序编译时,编译器将程序中出现的内联函数的调用表达式用内联函数的 函数体来进行替换。显然,这种做法不会产生转去转回的问题,但是由于在编译 时将函数休中的代码被替代到程序中,因此会增加目标程序代码量,进而增加空 间开销,而在时间代销上不象函数调用时那么大,可见它是以目标代码的增加为 代价来换取时间的节省。

    内联函数的定义方法

    定义内联函数的方法很简单,只要在函数定义的头前加上关键字inline即可 。内联函数的定义方法与一般函数一样。如:

    inline int add_int (int x, int y, int z)

      {

      return x+y+z;

      }

    在程序中,调用其函数时,该函数在编译时被替代,而不是像一般函数那样 是在运行时被调用。

    使用内联函数应注意的事项

    内联函数具有一般函数的特性,它与一般函数所不同之处公在于函数调用的 处理。一般函数进行调用时,要将程序执行权转到被调用函数中,然后再返回到 调用它的函数中;而内联函数在调用时,是将调用表达式用内联函数体来替换。 在使用内联函数时,应注意如下几点:

    1.类内定义的函数是内联函数,类外定义的函数是非内联函数(短函数可以 定义在类内,长函数可以定义在类外)。

    2.可以为类外定义的函数指定 inline 关键字,强行为内联函数。

    3.在内联函数内不允许用循环语句和开关语句。

    4.内联函数的定义必须出现在内联函数第一次被调用之前

    展开全文
  • 引入内联函数主要目的是,用它替代C语言中表达式形式的宏定义来解决程序中函数调用的效率问题。在C语言里可以使用如下的宏定义。 #define ExpressionName(Var1,Var2)(Var1+Var2)*(Var1-Var2) 这种宏定义在形式及...

    考点

    理解内联函数的作用,为什么要引入内联函数

    出现频率:★★★★

    【解析】
    引入内联函数的主要目的是,用它替代C语言中表达式形式的宏定义来解决程序中函数调用的效率问题。在C语言里可以使用如下的宏定义。

    #define ExpressionName(Var1,Var2)(Var1+Var2)*(Var1-Var2)
    

    这种宏定义在形式及使用上像一个函数,但它使用预处理器实现,没有了参数压栈、代码生成等一系列的操作,因此效率很高。这种宏定义在形式上类似于一个函数,但在使用它时,仅仅只是做预处理器符号表中的简单替换,因此它不能进行参数有效性的检测,也就不能享受C++编译器严格类型检查的好处。另外,它的返回值也不能被强制转换为可转换的合适类型,这样,它的使用就存在着一系列的隐患和局限性。

    另外,在C++中引入了类及类的访问控制,这样,如果一个操作或者说一个表达式涉及类的保护成员或私有成员,你就不可能使用这种宏定义来实现(因为无法将 this 指针放在合适的位置)。

    inline推出的目的,也正是为了取代这种表达式形式的宏定义。它消除了它的缺点,同时又很好地继承了它的优点。

    展开全文
  • 引入内联函数目的是为了解决程序中函数调用的效率问题。 函数是一种更高级的抽象。它的引入使得编程者只关心函数的功能和使用方法,而不必关心函数功能的具体实现;函数的引入可以减少程序的目标代码,实现程序...
    引入内联函数的目的是为了解决程序中函数调用的效率问题。 函数是一种更高级的抽象。它的引入使得编程者只关心函数的功能和使用方法,而不必关心函数功能的具体实现;函数的引入可以减少程序的目标代码,实现程序代码和数据的共享。但是,函数调用也会带来降低效率的问题,因为调用函数实际上将程序执行顺序转移到函数所存放在内存中某个地址,将函数的程序内容执行完后,再返回到转去执行该函数前的地方。这种转移操作要求在转去前要保护现场并记忆执行的地址,转回后先要恢复现场,并按原来保存地址继续执行。因此,函数调用要有一定的时间和空间方面的开销,于是将影响其效率。特别是对于一些函数体代码不是很大,但又频繁地被调用的函数来讲,解决其效率问题更为重要。引入内联函数实际上就是为了解决这一问题。 在程序编译时,编译器将程序中出现的内联函数的调用表达式用内联函数的函数体来进行替换。显然,这种做法不会产生转去转回的问题,但是由于在编译时将函数休中的代码被替代到程序中,因此会增加目标程序代码量,进而增加空间开销,而在时间代销上不象函数调用时那么大,可见它是以目标代码的增加为代价来换取时间的节省。 内联函数的定义方法 定义内联函数的方法很简单,只要在函数定义的头前加上关键字inline即可。内联函数的定义方法与一般函数一样。如: inline int add_int (int x, int y, int z) { return x+y+z; } 在程序中,调用其函数时,该函数在编译时被替代,而不是像一般函数那样是在运行时被调用。 使用内联函数应注意的事项 内联函数具有一般函数的特性,它与一般函数所不同之处公在于函数调用的处理。一般函数进行调用时,要将程序执行权转到被调用函数中,然后再返回到调用它的函数中;而内联函数在调用时,是将调用表达式用内联函数体来替换。在使用内联函数时,应注意如下几点: 1.在内联函数内不允许用循环语句和开关语句。 2.内联函数的定义必须出现在内联函数第一次被调用之前。 3.本栏目讲到的类结构中所有在类说明内部定义的函数是内联函数。
    展开全文
  • Kotlin总结之内联函数

    千次阅读 2020-03-07 12:06:57
    但可以通过内联函数优化。 一. 优化Lambda开销 在Kotlin中每次声明一个Lambda表达式,就会在字节码中产生一个匿名类。该匿名类包含了一个invoke方法,作为Lambda的调用方法,每次调用的时候,还会创建一个新的对象...

    在Kotlin 中使用 Lambda表达式会带来一些额外的开销。但可以通过内联函数优化。

    一. 优化Lambda开销

    在Kotlin中每次声明一个Lambda表达式,就会在字节码中产生一个匿名类。该匿名类包含了一个invoke方法,作为Lambda的调用方法,每次调用的时候,还会创建一个新的对象。可想而知,Lambda虽然简洁,但是会增加额外的开销。Kotlin 采用内联函数来优化Lambda带来的额外开销。

    1.1 invokedynamic

    Java如何解决优化Lambda的问题的呢?与Kotlin这种在编译期通过硬编码生成Lambda转换类的机制不同,Java在SE7之后,通过invokedynamic技术实现了在运行期间才产生相应的翻译代码。在invokedynamic被首次调用的时候,就会触发产生一个匿名内部类来替换中间码invokedynamic,后续的调用会直接采用这个匿名类的代码。

    这样做的好处是:

    1.由于具体的转换实现是在运行时产生的,在字节码中能看到的只有一个固定的invokedynamic,所以需要静态生成的类的个数以及字节码大小显著减少。

    2.与编译时写死在字节码中的策略不同,利用invokedynamic可以把实际的翻译策略隐藏在JDK库的实现,提高了灵活性,在确保向后兼容性的同时,后期可以继续对翻译策略不断优化升级。

    3.JVM天然支持类针对该方式对Lambda表达式的翻译和优化,开发者不必考虑这个问题。

    1.2内联函数

    invokedynamic虽然不错,但是Kotlin需要兼容Android最主流的Java版本SE6,这导致Kotlin无法使用invokedynamic来解决android平台Lambda开销的问题。所以Kotlin使用内联函数来解决这个问题,在Kotlin中使用inline关键字来修饰函数,这些函数就成了内联函数。它们的函数体在编译的时期被嵌入到每一个调用的地方,以减少额外生成的匿名类数,以及函数执行的时间开销。

    2.内联函数具体语法

    声明一个高阶函数payFoo,可以接收一个类型为()->Unit的Lambda,然后在main函数中调用它。

    fun main() {
        payFoo {
            println("write kotlin...")
        }
    }
    fun payFoo(block: () -> Unit) {
        println("before block")
        block()
        println("end block")
    }

    通过字节码反编译的相关Java代码。

    public final class InlineDemoKt {
       public static final void main() {
          payFoo((Function0)null.INSTANCE);
       }
    
       // $FF: synthetic method
       public static void main(String[] var0) {
          main();
       }
    
       public static final void payFoo(@NotNull Function0 block) {
          Intrinsics.checkParameterIsNotNull(block, "block");
          String var1 = "before block";
          System.out.println(var1);
          block.invoke();
          var1 = "end block";
          System.out.println(var1);
       }
    }

    可以发现调用payFoo后就会产生一个Function0类型的block类,然后通过invoke 方法来执行,这会增加额外的生成类和函数调用开销。

    现在通过inline修饰payFoo函数:

    fun main() {
        payFoo {
            println("write kotlin...")
        }
    }
    inline fun payFoo(block: () -> Unit) {
        println("before block")
        block()
        println("end block")
    }
    public final class InlineDemoKt {
       public static final void main() {
          int $i$f$payFoo = false;
          String var1 = "before block";
          System.out.println(var1);
          int var2 = false;
          String var3 = "write kotlin...";
          System.out.println(var3);
          var1 = "end block";
          System.out.println(var1);
       }
    
       // $FF: synthetic method
       public static void main(String[] var0) {
          main();
       }
    
       public static final void payFoo(@NotNull Function0 block) {
          int $i$f$payFoo = 0;
          Intrinsics.checkParameterIsNotNull(block, "block");
          String var2 = "before block";
          System.out.println(var2);
          block.invoke();
          var2 = "end block";
          System.out.println(var2);
       }
    }

    可以发现通过inline修饰的函数,其函数体代码被调用的Lambda代码都粘贴到了相应调用的位置。试想一下,如果这是一个工程中公共的方法,或者被嵌套在一个循环调用的逻辑体中,这个方法必然会被调用多次。通过inline语法,可以彻底消除这种额外调用,从而节约了开销。

    内联函数典型的一个应用场景就是Kotlin的集合类。如果你看过 Kotlin的集合类API文档或者源码实现,可以发现,集合函数式API,如map、filter都被定义成了内联函数。

    /**
     * Returns a list containing the results of applying the given [transform] function
     * to each element in the original array.
     */
    public inline fun <T, R> Array<out T>.map(transform: (T) -> R): List<R> {
        return mapTo(ArrayList<R>(size), transform)
    }
    /**
     * Returns a list containing only elements matching the given [predicate].
     */
    public inline fun <T> Array<out T>.filter(predicate: (T) -> Boolean): List<T> {
        return filterTo(ArrayList<T>(), predicate)
    }

    因为上面的方法都接收Lambda作为参数,同时需要对集合元素进行遍历操作,所以会定义为内联函数。

    内联函数不是万能的,以下情况避免使用内联函数:

    1.由于JVM对普通函数已经能够根据实际情况智能地判断是否进行内联优化,所以我们并不需要对其使用Kotlin的inline语法,那只会让字节码变得更加复杂。

    2.尽量避免对具有大量函数体的函数进行内联,这样会导致过多的字节码数量。

    3.一旦一个函数被定义为内联函数,便不能获取闭包类的私有成员,除非你把它们声明为internal。

    下面就是错误写法,本质是private修饰的a没有get 方法。

    class TestPay {
          private var a = 1  //错误写法,会报错
    
         inline fun printNumber() {
            println(a)
        }
    }

     

    二.noinline :避免参数被内联

    如果一个函数的开头加上inline修饰符,那么它的函数体以及Lambda参数都会被内联。然而现实中的情况比较复杂,有一种可能是函数需要接收多个参数,但我们只想对其中部分Lambda参数内联,其他的则不内联,应该如何处理?

    Kotlin引入了noinline关键字,可以加在不想要内联的参数开头,该参数便不会有内联效果。

    fun main() {
        payFoo({
            println("I am inlined...")
        }, {
            println("I am not inlined...")
        })
    }
    
    inline fun payFoo(block1: () -> Unit, noinline block2: () -> Unit) {
        println("before block")
        block1()
        block2()
        println("end block")
    }
    
    before block
    I am inlined...
    I am not inlined...
    end block

    可以发现block1被内联了,block2没有被内联。

    public final class NoinlineDemoKt {
       public static final void main() {
          Function0 block2$iv = (Function0)null.INSTANCE;
          int $i$f$payFoo = false;
          String var2 = "before block";
          System.out.println(var2);
          int var3 = false;
          //可以发现block1被内联了。
          String var4 = "I am inlined...";
          System.out.println(var4);
          //block2没有被内联
          block2$iv.invoke();
          var2 = "end block";
          System.out.println(var2);
       }
    
       // $FF: synthetic method
       public static void main(String[] var0) {
          main();
       }
    
       public static final void payFoo(@NotNull Function0 block1, @NotNull Function0 block2) {
          int $i$f$payFoo = 0;
          Intrinsics.checkParameterIsNotNull(block1, "block1");
          Intrinsics.checkParameterIsNotNull(block2, "block2");
          String var3 = "before block";
          System.out.println(var3);
          block1.invoke();
          block2.invoke();
          var3 = "end block";
          System.out.println(var3);
       }
    }

     从上面的代码中可以看出,payFoo函数中block2函数在带上noinline之后,反编译后的Java代码中没有将其函数体代码在调用处进行替换。

     

    三.非局部返回

    Kotlin中内联函数除了优化Lambda开销之外,还带来了非局部返回和具体化参数类型。

    1.Kotlin如何支持非局部返回

    首先看常见的局部返回的例子

    fun main() {
        payFoo()
    }
    
    fun localReturn() {
        return
    }
    
    fun payFoo() {
        println("before local return")
        localReturn()
        println("after local return")
        return
    }
    
    before local return
    after local return

    从上面代码可以发现,localReturn执行之后,其函数体中的return只会在该函数的局部生效,所以localReturn()之后的println函数依旧生效。

    如何把函数换成Lambda版本,(存在问题的写法)

    fun main() {
        payFoo { return }
    }
    
    fun payFoo(returning: () -> Unit) {
        println("before local return")
        returning()
        println("after local return")
        return
    }
    
    'return' is not allowed here

    从上面的代码可以发现报错了,在Kotlin中,正常情况下,Lambda表达式不允许存在return关键字。

    通过内联函数修改

    fun main() {
        payFoo { return }
    }
    
    inline fun payFoo(returning: () -> Unit) {
        println("before local return")
        returning()
        println("after local return")
        return
    }
    
    before local return

    编译通过,但结果与局部返回不同,Lambda的return执行之后直接让foo函数退出了执行。因为内联函数payFoo的函数体及参数Lambda会直接替代具体的调用,所以实际产生的代码中,return相当于是直接暴露在main函数中的,所以returning之后的代码就不会执行了,这就是非局部返回。

    public final class Testinline3Kt {
       public static final void main() {
          int $i$f$payFoo = false;
          String var1 = "before local return";
          System.out.println(var1);
          int var2 = false;
       }
    
       // $FF: synthetic method
       public static void main(String[] var0) {
          main();
       }
    
       public static final void payFoo(@NotNull Function0 returning) {
          int $i$f$payFoo = 0;
          Intrinsics.checkParameterIsNotNull(returning, "returning");
          String var2 = "before local return";
          System.out.println(var2);
          returning.invoke();
          var2 = "after local return";
          System.out.println(var2);
       }
    }

    使用标签实现Lambda非局部返回

    另一种等效的方式,是通过标签利用@符号来实现Lambda非局部返回。可以在不声明inline修饰符的情况下,实现相同效果。

    fun main() {
        payFoo2 { return@payFoo2 }
    }
    
    fun payFoo2(returning: () -> Unit) {
        println("before local return")
        returning()
        println("after local return")
        return
    }
    
    before local return
    after local return

    非局部返回尤其在循环控制中特别有用,比如Kotlin的forEach接口,它接收一个Lambda参数,由于它也是一个内联函数,所以可以直接在它调用的Lambda中执行return退出上一层的程序。

    fun main() {
        println(hasZero(listOf(0,2,3)))
    }
    
    fun hasZero(list: List<Int>): Boolean {
        list.forEach {
            if (it == 0) return true //直接返回结果
        }
        return false
    }
    
    true

    crossinline

    非局部返回在某些场合下非常有用,但可能存在风险,内联的函数所接收的Lambda参数常常来自于上下文的其他地方。为了避免带有return的Lambda参数产生破坏,可以使用crossinline 关键字来修饰该参数。

    fun main() {
        payFoo3 {
            return
        }
    }
    
    inline fun payFoo3(crossinline returning: () -> Unit) {
        println("before local return")
        returning()
        println("after local return")
        return
    }
    
    'return' is not allowed here

     

    四.具体化参数类型

    内联函数可以帮助我们实现具体化参数类型,Kotlin与Java一样,由于运行时的类型擦除,我们不能直接获取一个参数的类型。然而,由于内联函数会直接在字节码中生成相应的函数体实现,这时候反而可以获得参数的具体类型。

    使用reified修饰符来实现这一效果。

    fun main() {
        getType<Int>()
    }
    
    
    inline fun <reified T> getType() {
        println(T::class)
    }
    
    class java.lang.Integer (Kotlin reflection is not available)

    这个特性在android开发中也特别有用,在Java中,需要调用startActivity时,通常需要把具体的目标视图类作为一个参数。但是在Kotlin中,可以使用reified来进行简化。

    import android.app.Activity
    import android.content.Intent
    
    inline fun <reified T : Activity> Activity.startActivity() {
        startActivity(Intent(this, T::class.java))
    }

     

    参考<<Kotlin核心编程>> 

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • c++中简单的内联函数

    2019-09-15 19:43:58
    在c中我们经常把一些短并且执行频繁的计算写成宏,而不是函数,这样做的理由是为了执行效率,宏可以避免函数调用的开销,这些都由预处理来完成。 但是在c++出现之后,使用预处理宏会出现两个问题: 第一个在c中也会...
  • Java的内联函数

    2019-06-13 15:06:02
    “所谓内联函数就是指函数在被调用的地方直接展开,编译器在调用时不用像一般函数那样,参数压栈,返回时参数出栈以及资源释放等,这样提高了程序执行速度。 对应Java语言中也有一个关键字final来指明那个函数是内联...
  • 友元函数,内联函数

    2018-10-13 00:25:52
    类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 内联函数与宏定义的函数很相似,都是在运行前,先将一些简短的函数,直接替换为实现代码,以此来省去函数调用时,参数入栈、程序跳转等的时间开支。 宏定义的函数: 使用宏定义#define定义的函数。其在预编译阶段就...
  • 内联函数从源代码层看,有函数的结构,而在编译后,却不具备函数的性质。内联函数不是在调用时发生控制转移,而是在编译时将函数体嵌入在每一个调用处。编译时,类似宏替换,使用函数体替换调用处的函数名。一般在...
  • 内联函数和宏定义函数的区别

    千次阅读 2019-05-17 19:53:55
    在编译的时候,内联函数直接被嵌入到目标代码中去,而宏只是一个简单的文本替换。 内联函数可以进行诸如类型安全检查、语句是否正确等编译功能,宏不具有这样的功能;宏不是函数,而inline是函数。 宏在定义时要...
  • 1:引入内联函数主要目的是,用它替代C语言中表达形式的宏定义来解决程序中函数调用的效率问题。在C语言里可以使用如下的宏定义: #define ExpressionName(Var1,Var2) (Var1+Var2)*(Var1-Var2) 这种宏定义在...
  • Java内联函数

    千次阅读 2020-10-30 16:36:25
    内联函数 在说内联函数之前,先说说函数的调用过程。 调用某个函数实际上将程序执行顺序转移到该函数所存放在内存中某个地址,将函数的...那怎么解决这个性能消耗问题呢,这个时候需要引入内联函数了。内联函数就是
  • 内联函数是C++语言新引入的概念。其目的是为了提高函数的执行效率。宏是C++从它的前辈C继承而来的,宏同样可以提高代码的执行效率,减少函数执行过程中的调用开销。不是所有函数都适合声明为内联函数。即使声明为...
  • C++内联函数机制全面解析

    千次阅读 2017-01-19 14:31:26
    内联函数机制的引入 内联机制被引入C++作为对宏(Macro)机制的改进和补充(不是取代)。内联函数的参数传递机制与普通函数相同。但是编译器会在每处调用内联函数的地方将内联函数的内容展开。这样既避免了函数调用...
  • C语言内联函数

    千次阅读 2019-06-06 17:19:41
    引入内联函数目的是为了解决程序中函数调用的效率问题。 函数是一种更高级的抽象。它的引入使得编程者只关心函数的功能和使用方法,而不必关心函数功能的具体实现;函数的引入可以减少程序的目标代码,实现程序...
  • 内联函数

    2021-05-06 20:09:36
    被inline关键字修饰的函数称为内联函数,引入内联函数目的是为了解决程序中函数调用的效率问题。 如果一个函数被定义为内联函数,那么编译器会在函数被调用的位置将其展开,以定义的函数体进行替换,这样就不用再...
  • 介绍内联函数之前,有必要介绍一下预处理宏。内联函数的功能和预处理宏的功能相似。相信大家都用过预处理宏,我们会经常定义一些宏,如 复制代码 代码如下: #define TABLE_COMP(x) ((x)>0?(x):0) 就...
  • 引入内联函数目的是为了解决程序中函数调用的效率问题。前面我们讲过,函数的引入使得编程者只关心函数的功能和使用方法,而不必关心函数功能的具体实现;另外,函数的引入可以减少程序的代码,实现程序代码和数据...
  • C++ 内联函数

    2019-08-05 15:52:43
    内联函数 C++ 内联函数是通常与类一起使用。如果一个函数是内联的,那么在编译时,编译器会把该函数的代码副本放置在每个调用该函数的地方。 对内联函数进行任何修改,都需要重新编译函数的所有客户端,因为编译器...
  • 内联函数 定义: 建议: For function-like macros, prefer inline functions to #defines 对于类似宏的函数,首选内联函数来定义 (某些函数被重复调用多次,可以考虑把函数设置为内联函数) 注意: 和宏...
  • 内联函数提高函数调用效率

    千次阅读 2018-01-03 20:44:32
    存在函数频繁调用时,内联函数通过牺牲空间换取时间的节省。
  • 引入内联函数目的是为了解决程序中函数调用的效率问题。 函数是一种更高级的抽象。它的引入使得编程者只关心函数的功能和使用方法,而不必关心函数功能的具体实现;函数的引入可以减少程序的目标代码,实现程序...
  • 一:函数回顾与后置返回类型 函数定义中,形参如果在函数体内用不到的话,则可以不给形参变量名字,只给其类型。 函数声明时,可以只有形参类型,...在函数定义前增加了关键字inline,导致该函数变成内联函数。 函数
  • inline内联函数详解

    2019-08-21 17:29:54
    (1)引入inline关键字的原因:在c/c++中,为了解决一些频繁调用的小函数大量消耗栈空间(栈内存)的问题,特别的引入了inline修饰符,表示为内联函数,栈空间就是指放置程序的局部数据(也就是函数内数据)的内存...
  • 什么是内联函数

    千次阅读 多人点赞 2018-11-04 22:34:15
    内联函数inline:引入内联函数目的是为了解决程序中函数调用的效率问题,这么说吧,程序在编译器编译的时候,编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换,而对于其他的函数,都是在运行...
  • JAVA中的内联函数

    千次阅读 2017-06-19 13:10:40
    在说内联函数之前,先说说函数的调用过程。 调用某个函数实际上将程序执行顺序转移到该函数所存放在内存中某个地址,将函数的程序内容执行完后,再返回到 转去执行该函数前的地方。这种转移操作要求在转去前要保护...
  • 在c中,为了解决一些频繁调用的小函数大量消耗栈空间或是叫栈内存的问题,特别的引入了inline修饰符,表示为内联函数数。栈空间就是指放置程序的局部数据也就是函数内数据的内存空间,在系统下,栈空间是有限的,假如...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,356
精华内容 8,142
关键字:

引入内联函数的主要目的