精华内容
下载资源
问答
  • 函数前加static关键字

    千次阅读 2018-04-19 14:13:31
    1.函数前加static关键字函数就被定义成为静态函数函数的定义和声明默认情况下是extern的,但静态函数只是声明他的文件当中可见,不能被其他文件所用。定义静态函数的好处:<1> 静态函数不能被...
    1.函数名前加static关键字
    
    函数就被定义成为静态函数。
    函数的定义和声明默认情况下是extern的,但静态函数只是在声明他的文件当中可见,不能被其他文件所用。
    定义静态函数的好处:
    <1> 静态函数不能被其他文件所用。
    <2> 其他文件中可以定义相同名字的函数,不会发生冲突。
    <3> 静态函数会被自动分配在一个一直使用的存储区,直到退出应用程序实例,避免了调用函数时压栈出栈,速度快很多。

    引申学习:
    static变量与static函数
    静态局部变量在函数内定义,生存期为整个源程序,但作用域为函数内。退出该函数后, 尽管该变量还继续存在,但不能使用它。
    (对基本类型的静态局部变量若在说明时未赋以初值,则系统自动赋予0值。而对自动变量不赋初值,则其值是不定的。)
    展开全文
  • 函数4.6. 定义函数4.7. 函数定义的更多形式4.7.1. 参数默认值 4.6. 定义函数 我们可以创建一个输出任意范围内 Fibonacci 数列的函数: >>> def fib(n): # write Fibonacci series up to n ... """Print a ...

    4.6. 定义函数

    我们可以创建一个输出任意范围内 Fibonacci 数列的函数:

    >>> def fib(n):    # write Fibonacci series up to n
    ...     """Print a Fibonacci series up to n."""
    ...     a, b = 0, 1
    ...     while a < n:
    ...         print(a, end=' ') # end=' ',print()的结果不换行,而是空格输出
    ...         a, b = b, a+b
    ...     print()
    ...
    >>> # Now call the function we just defined:
    ... fib(2000)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
    

    函数的 执行 会引入一个用于函数局部变量的新符号表。 更确切地说,函数中所有的变量赋值都将存储在局部符号表中;而变量引用会首先在局部符号表中查找,然后是外层函数的局部符号表,再然后是全局符号表,最后是内置名称的符号表。 因此,全局变量和外层函数的变量不能在函数内部直接赋值(除非是在 global 语句中定义的全局变量,或者是在 nonlocal 语句中定义的外层函数的变量),尽管它们可以被引用。

    在函数被调用时,实际参数(实参)会被引入被调用函数的本地符号表中;因此,实参是通过 按值调用 传递的(其中 值 始终是对象 引用 而不是对象的值)。当一个函数调用另外一个函数时,将会为该调用创建一个新的本地符号表。

    函数定义会把函数名引入当前的符号表中。函数名称的值具有解释器将其识别为用户定义函数的类型。这个值可以分配给另一个名称,该名称也可以作为一个函数使用。这用作一般的重命名机制:

    >>> fib
    <function fib at 10042ed0>
    >>> f = fib
    >>> f(100)
    0 1 1 2 3 5 8 13 21 34 55 89
    

    如果你学过其他语言,你可能会认为 fib 不是函数而是一个过程,因为它并不返回值。事实上,即使没有 return 语句的函数也会返回一个值,尽管它是一个相当无聊的值。这个值称为 None (它是内置名称)。一般来说解释器不会打印出单独的返回值 None ,如果你真想看到它,你可以使用 print()

    >>> fib(0)
    >>> print(fib(0))
    None
    

    写一个返回斐波那契数列的列表(而不是把它打印出来)的函数,非常简单:

    >>> def fib2(n):  # return Fibonacci series up to n
    ...     """Return a list containing the Fibonacci series up to n."""
    ...     result = []
    ...     a, b = 0, 1
    ...     while a < n:
    ...         result.append(a)    # see below
    ...         a, b = b, a+b
    ...     return result
    ...
    >>> f100 = fib2(100)    # call it
    >>> f100                # write the result
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    
    • return 语句会从函数内部返回一个值。 不带表达式参数的 return 会返回 None。 函数执行完毕退出也会返回 None

    • result.append(a) 语句调用了列表对象 result 的 方法 。方法是“属于”一个对象的函数,它被命名为 obj.methodname ,其中 obj 是某个对象(也可能是一个表达式), methodname 是由对象类型中定义的方法的名称。不同的类型可以定义不同的方法。不同类型的方法可以有相同的名称而不会引起歧义。(可以使用 类 定义自己的对象类型和方法,请参阅 类 )示例中的方法 append() 是为列表对象定义的;它会在列表的最后添加一个新的元素。在这个示例中它相当于 result = result + [a] ,但更高效。

    4.7. 函数定义的更多形式

    给函数定义有可变数目的参数也是可行的。这里有三种形式,可以组合使用。

    4.7.1. 参数默认值

    最有用的形式是对一个或多个参数指定一个默认值。这样创建的函数,可以用比定义时允许的更少的参数调用,比如:

    def ask_ok(prompt, retries=4, reminder='Please try again!'):
        while True:
            ok = input(prompt)
            if ok in ('y', 'ye', 'yes'):#元组中是否包含ok
                return True
            if ok in ('n', 'no', 'nop', 'nope'):
                return False
            retries = retries - 1
            if retries < 0:
                raise ValueError('invalid user response')
            print(reminder)
    

    这个函数可以通过几种方式调用:

    • 只给出必需的参数:ask_ok('Do you really want to quit?')
    • 给出一个可选的参数:ask_ok('OK to overwrite the file?', 2)
    • 或者给出所有的参数:ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')
      这个示例还介绍了 in 关键字。它可以测试一个序列是否包含某个值。

    默认值是在 定义过程 中在函数定义处计算的,所以

    i = 5
    
    def f(arg=i):
        print(arg)
    
    i = 6
    f()
    

    会打印 5。

    重要警告默认值只会执行一次。这条规则在默认值为可变对象(列表、字典以及大多数类实例)时很重要。比如,下面的函数会存储在后续调用中传递给它的参数:

    def f(a, L=[]):
        L.append(a)
        return L
    
    print(f(1))
    print(f(2))
    print(f(3))
    

    这将打印出

    [1]
    [1, 2]
    [1, 2, 3]
    

    如果你不想要在后续调用之间共享默认值,你可以这样写这个函数:

    def f(a, L=None):
        if L is None:
            L = []
        L.append(a)
        return L
    

    4.7.2. 关键字参数

    也可以使用形如 kwarg=value 的 关键字参数 来调用函数。例如下面的函数:

    def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
        print("-- This parrot wouldn't", action, end=' ')
        print("if you put", voltage, "volts through it.")
        print("-- Lovely plumage, the", type)
        print("-- It's", state, "!")
    

    接受一个必需的参数(voltage)和三个可选的参数(state, action,和 type)。这个函数可以通过下面的任何一种方式调用:

    parrot(1000)                                          # 1 positional argument
    parrot(voltage=1000)                                  # 1 keyword argument
    parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
    parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
    parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
    parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword
    

    但下面的函数调用都是无效的:

    parrot()                     # required argument missing
    parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
    parrot(110, voltage=220)     # duplicate value for the same argument
    parrot(actor='John Cleese')  # unknown keyword argument
    

    在函数调用中,关键字参数(voltage=5.0)必须跟随在位置参数('dead')的后面。传递的所有关键字参数必须与函数接受的其中一个参数匹配(比如 actor 不是函数 parrot 的有效参数),它们的顺序并不重要(parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments)。这也包括非可选参数,(比如 parrot(voltage=1000) 也是有效的)。不能对同一个参数多次赋值。下面是一个因为此限制而失败的例子:

    >>> def function(a):
    ...     pass
    ...
    >>> function(0, a=0)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: function() got multiple values for keyword argument 'a'
    

    当存在一个形式为 **name (

    shopkeeper="Michael Palin",
               client="John Cleese",
               sketch="Cheese Shop Sketch"
    

    )的最后一个形参时,它会接收一个字典 (参见 映射类型 — dict),其中包含除了与已有形参相对应的关键字参数以外的所有关键字参数(name='pf')。 这可以与一个形式为 *name"It's very runny, sir.", "It's really very, VERY runny, sir."),接收一个包含除了已有形参列表以外的位置参数的 元组 的形参 (将在下一小节介绍) 组合使用 (*name 必须出现在 **name 之前。这样就不会违背关键字参数在位置参数之后这条原则了) 例如,如果我们这样定义一个函数:

    def cheeseshop(kind, *arguments, name='pf',**keywords):
        print("-- Do you have any", kind, "?")
        print("-- I'm sorry, we're all out of", kind)
        print("what is your name ,my name is ",name)
        for arg in arguments:
            print(arg)
        print("-" * 40)
        for kw in keywords:
            print(kw, ":", keywords[kw])    
    

    它可以像这样调用:

    cheeseshop("Limburger", "It's very runny, sir.",
               "It's really very, VERY runny, sir.",
               shopkeeper="Michael Palin",
               client="John Cleese",
               sketch="Cheese Shop Sketch")
    

    当然它会打印:

    -- Do you have any Limburger ?
    -- I'm sorry, we're all out of Limburger
    what is your name ,my name is  pf
    It's very runny, sir.
    It's really very, VERY runny, sir.
    ----------------------------------------
    shopkeeper : Michael Palin
    client : John Cleese
    sketch : Cheese Shop Sketch
    
    展开全文
  • c++中的static关键字使得函数里面的局部变量的存活期不局限于函数里面,而是变为整个程序生命期里面都有效
  • 关于函数前加static的一些解释说法一:在函数的返回类型前加上关键字static,函数就被定义成为静态函数函数的定义和声明默认情况下是extern的,但静态函数只是声明他的文件当中可见,不能被其他文件所用。定义...

    关于函数名前加static的一些解释

    说法一:

    在函数的返回类型前加上关键字static,函数就被定义成为静态函数。函数的定义和声明默认情况下是extern的,但静态函数只是在声明他的文件当中可见,不能被其他文件所用。定义静态函数的好处:
    <1> 其他文件中可以定义相同名字的函数,不会发生冲突
    <2> 静态函数不能被其他文件所用。

     存储说明符auto,register,extern,static,对应两种存储期:自动存储期和静态存储期。 auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立,它在该程序块活动时存在,退出该程序块时撤销。关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期(static storage duration),或静态范围(static extent)。虽然他的值在函数调用之间保持有效,但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。
    C语言中使用静态函数的好处:
          静态函数会被自动分配在一个一直使用的存储区,直到退出应用程序实例,避免了调用函数时压栈出栈,速度快很多。 
          关键字“static”,译成中文就是“静态的”,所以内部函数又称静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件。 使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名,因为同名也没有关系。 
    c语言中static的语义

    1.static变量:1).局部a.静态局部变量在函数内定义,生存期为整个源程序,但作用域与自动变量相同,只能在定义该变量的函数内使用。退出该函数后, 尽管该变量还继续存在,但不能使用它。b.对基本类型的静态局部变量若在说明时未赋以初值,则系统自动赋予0值。而对自动变量不赋初值,则其值是不定的。2).全局全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。但是他们的作用域,非静态全局 变量的作用域是整个源程序(多个源文件可以共同使用); 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效, 在同一源程序的其它源文件中不能使用它。

    2.static函数(也叫内部函数)只能被本文件中的函数调用,而不能被同一程序其它文件中的函数调用。区别于一般的非静态函数(外部函数)     static在c里面可以用来修饰变量,也可以用来修饰函数。先看用来修饰变量的时候。变量在c里面可分为存在全局数据区、栈和堆里。其实我们平时所说的堆栈是栈而不包含对,不要弄混。

    说法二:

          在C里面,所谓 static ,只是限制在当前源文件————这个只是对于编译器/链接器而言。但实际上,运行时,static和普通的extern 的函数/变      量,没有区别。


    例如:

    static int8u i2c_read_char(i2c_bus_t *i2c, int32u pos)
    {
            int32u c = 0;
    i2c_set_address(i2c, pos);
    I2CMasterSlaveAddrSet(i2c->base, i2c->device_address >> 1, true);
        
    HWREG(i2c->base + I2C_O_MCS) = I2C_MASTER_CMD_SINGLE_RECEIVE;
    while(I2CMasterBusy(i2c->base))
         {

         }
        c = I2CMasterDataGet(i2c->base);
        return (int8u)(c);
    }

    展开全文
  • C语言中,如果一些函数被频繁调用,不断地有函数入栈,即函数栈,会造成栈空间或栈内存的大量消耗。 为了解决这个问题,特别的引入了inline修饰符,表示为内联函数。 栈空间就是指放置程式的局部数据也就是...

    原文:https://blog.csdn.net/zqixiao_09/article/details/50877383

    一、什么是内联函数

           在C语言中,如果一些函数被频繁调用,不断地有函数入栈,即函数栈,会造成栈空间或栈内存的大量消耗。

           为了解决这个问题,特别的引入了inline修饰符,表示为内联函数

           栈空间就是指放置程式的局部数据也就是函数内数据的内存空间,在系统下,栈空间是有限的,假如频繁大量的使用就会造成因栈空间不足所造成的程式出错的问题,函数的死循环递归调用的最终结果就是导致栈内存空间枯竭。

    下面我们来看一个例子:

     
    1. #include <stdio.h>

    2.  
    3. //函数定义为inline即:内联函数

    4. inline char* dbtest(int a)

    5. {

    6. return (i % 2 > 0) ? "奇" : "偶";

    7. }

    8.  
    9. int main()

    10. {

    11. int i = 0;

    12. for (i=1; i < 100; i++)

    13. {

    14. printf("i:%d 奇偶性:%s /n", i, dbtest(i));

    15. }

    16. }

     

         上面的例子就是标准的内联函数的用法,使用inline修饰带来的好处我们表面看不出来,其实在内部的工作就是在每个for循环的内部任何调用dbtest(i)的地方都换成了(i%2>0)?"奇":"偶"这样就避免了频繁调用函数对栈内存重复开辟所带来的消耗。

         其实这种有点类似咱们前面学习的动态库和静态库的问题,使 dbtest 函数中的代码直接被放到main 函数中,执行for 循环时,会不断调用这段代码,而不是不断地开辟一个函数栈。

     

    二、内联函数的编程风格

    1、关键字inline 必须与函数定义体放在一起才能使函数成为内联,仅将inline 放在函数声明前面不起任何作用

    如下风格的函数Foo 不能成为内联函数:

     
    1. inline void Foo(int x, int y); // inline 仅与函数声明放在一起

    2. void Foo(int x, int y)

    3. {

    4. }

     

    而如下风格的函数Foo 则成为内联函数:

     
    1. void Foo(int x, int y);

    2. inline void Foo(int x, int y) // inline 与函数定义体放在一起

    3. {

    4. }

           所以说,inline 是一种 “用于实现的关键字” ,而不是一种“用于声明的关键字”。一般地,用户可以阅读函数的声明,但是看不到函数的定义。尽管在大多数教科书中内联函数的声明、定义体前面都加了inline 关键字,但我认为inline 不应该出现在函数的声明中。这个细节虽然不会影响函数的功能,但是体现了高质量C++/C 程序设计风格的一个基本原则:声明与定义不可混为一谈,用户没有必要、也不应该知道函数是否需要内联。

     

     

    2、inline的使用是有所限制的

          inline只适合涵数体内代码简单的函数数使用,不能包含复杂的结构控制语句例如while、switch,并且内联函数本身不能是直接递归函数(自己内部还调用自己的函数)。

     

    三、慎用内联

           内联能提高函数的执行效率,为什么不把所有的函数都定义成内联函数?如果所有的函数都是内联函数,还用得着“内联”这个关键字吗?

           内联是以代码膨胀(复制)为代价,仅仅省去了函数调用的开销,从而提高函数的执行效率。如果执行函数体内代码的时间,相比于函数调用的开销较大,那么效率的收
    获会很少。另一方面,每一处内联函数的调用都要复制代码,将使程序的总代码量增大,消耗更多的内存空间

    以下情况不宜使用内联:

    (1)如果函数体内的代码比较长,使用内联将导致内存消耗代价较高。

    (2)如果函数体内出现循环,那么执行函数体内代码的时间要比函数调用的开销大。

    一个好的编译器将会根据函数的定义体,自动地取消不值得的内联(这进一步说明了inline 不应该出现在函数的声明中)。

     

    总结:

           因此,将内联函数放在头文件里实现是合适的,省却你为每个文件实现一次的麻烦.而所以声明跟定义要一致,其实是指,如果在每个文件里都实现一次该内联函数的话,那么,最好保证每个定义都是一样的,否则,将会引起未定义的行为,即是说,如果不是每个文件里的定义都一样,那么,编译器展开的是哪一个,那要看具体的编译器而定.所以,最好将内联函数定义放在头文件中. 

    展开全文
  • 在函数定义加上inline关键字,就可以使用内联函数的特性。强调一下,必须是函数定义的地方,原因后面解释。普通函数和内联函数的主要区别是函数与程序的组合形式的不同。 首先,inline关键字在函数编译阶段生效,...
  • 函数被virtual关键字修饰时,该函数被称为虚函数,虚函数是指一个类中你希望重载的成员函数,当你用一个基类指针或引用指向一个继承类对象的时候,你调用一个虚函数,实际调用的是继承类的版本。虚函数最关键的...
  • 内联函数-C中关键字inline用法解析

    万次阅读 多人点赞 2019-06-28 13:59:16
    目录 内联函数-C中关键字inline用法解析 内联函数-C中关键字inline用法解析 一、什么是内联函数C语言中,如果一些函数被频繁调用,不断地有函数入栈,即函数栈,会造成栈空间或栈内存的大量消耗。 ​ 为了解决...
  • 内联函数 —— C 中关键字 inline 用法解析

    万次阅读 多人点赞 2016-03-13 13:37:36
     C语言中,如果一些函数被频繁调用,不断地有函数入栈,即函数栈,会造成栈空间或栈内存的大量消耗,为了解决,特别的引入了inline修饰符,表示为内联函数。  栈空间就是指放置程式的局部数据也就是函数内数据的...
  • 类声明中,使用 friend 关键字和非成员函数名称或其他类,以允许其访问你的类的专用和受保护成员。 语法 friend class-name; friend function-declarator; 友元声明 如果声明以前未声明的友元函数,则该函数将...
  • 转载自说说 Python 关键字与内置函数以及Python关键字和内置函数介绍 1 关键字 这些关键字都有特殊的含义, 如果我们将它们用作变量名, 就会引发错误: 1)and:逻辑与 2)as:为导入的模块取一个别名,...
  • inline关键字强制转为内联函数

    千次阅读 2016-05-12 20:45:00
    内联函数通知编译器用成员函数函数体替换掉所有对该函数进行调用的代码...进行成员函数声明的时候,使用inline关键字,可将原本定义类声明之外的成员函数强制变成内联函数 class Test{ Public: inline void myTe
  • C++函数后面throw关键字的含义

    千次阅读 2015-04-12 21:02:30
    C++函数后面后加关键字throw(something)限制,是对这个函数的异常安全性作出限制。 举例及解释如下: void fun() throw() 表示fun不允许抛出任何异常,即fun是异常安全的。 void fun() throw(...) 表示fun可以抛出...
  • 尽管大多数教科书中内联函数的声明、定义体前面都了inline 关键字,但我认为inline 不应该出现在函数的声明中。这个细节虽然不会影响函数的功能,但是体现了高质量C++/C 程序设计风格的一个基本原则:声明与定义...
  • 构造函数关键字

    2016-06-01 17:22:23
    构造函数 特点: 1.函数名与类名相同 2.不需要定义返回值类型 3.不可以写return语句 ...2.当类中自定义了构造函数后,默认的构造函数就消失了。 构造函数和一般函数的区别: 构造函数一建立就会运
  • (1)const是函数类型的一部分,实现部分也要带该关键字。 (2)const关键字可以用于对重载函数的区分。 (3)常成员函数不能更新类的成员变量,也不能调用该类中没有用const修饰的成员函数,只能调用常成员函数...
  • 【c++基础】5.标识符、关键字函数

    千次阅读 2017-06-08 16:18:02
    【一】标识符标识符是实体唯一标识,也就是实体名,比如变量名,函数名,类名,结构名等,都是标识符,标识符由用户(编程人员)自己定义,遵循一定的规则命名规则,具体如下: 第一个字符必须是字母(不分大小写)...
  • 想了解Java中static关键字的作用和用法详细介绍...当我们同时编译多个文件时,所有未static前缀的全局变量和函数都具有全局可见性。为理解这句话,我举例来说明。我们要同时编译两个源文件,一个是a.c,另一个是main
  • JavaScript 使用关键字 function 定义函数 函数可以通过声明定义,也可以是一个表达式。 函数声明 之前的教程中,你已经了解了函数声明的语法 : ? 1 2 3 function ...
  • 一、虚函数 概念:在函数前面virtual,就是虚函数 ... 虚函数需要在函数加上关键字virtual 成员函数如果不是虚函数,其解析过程发生编译时而非运行时 派生类可以不覆盖(重写)它继承的虚函数 ...
  • @著作权归作者所有:来自CSDN博客作者大胡子的艾娃的...a、直接二义性可以用作用域与同名覆盖的方法来消除(看程序注释),但是间接二义性(同名数据成员内存中同时拥有多个拷贝,同一个成员函数会有多个映射,多...
  • C++函数前后const的区别

    万次阅读 多人点赞 2019-05-26 17:59:25
    函数前const:普通函数或成员函数(非静态成员函数均可const修饰,表示函数的返回值为const,不可修改。格式为: const returnType functionName(param list) 函数const:只有类的非静态成员函数后...
  • Matlab自定义函数

    千次阅读 2015-06-30 11:03:57
    本文使用了范德堡大学教授Akos Ledeczi授课中的例子来一步步说明如何Matlab中自定义函数。 首先,command window中输入edit命令,开始编辑函数。本函数实现的是随机生成一个3行4列的矩阵,该矩阵的元素取值...
  • C语言32个关键字详解

    千次阅读 2020-08-04 22:01:06
    说明 auto 声明一个自动存储的变量 break 跳出当前循环 case 开关语句分支 char 声明字符型变量或函数返回值类型 const 定义常量,如果一个变量被 const 修饰,那么它的值就不能再被改变 continue ...
  • 村头王师傅教你学习C语言(一)C语言32个关键字

    千次阅读 多人点赞 2017-03-29 14:47:36
    C语言的关键字其实就是一些特定的英文单词,C语言中提供特定的功能,能够被C语言编译器作出特殊识别和解释的单词。一共有多少个关键字 C语言的关键字一共有32个,其中数据类型相关的关键字有12个,和控制语句...
  • 修饰类成员函数的几个关键字:inline, const, explicit, static
  • 内联函数

    千次阅读 2019-01-09 08:13:22
    内联函数 关键字: inline 也叫镶嵌函数 ...编译器看到inline后, (一般)为该函数创建一段代码, 以便后面每次调用都用一段代码来替换, 内联函数的初衷是为了空间换取时间的更快, 所以不能内联函数内加上...
  • 2. 定义函数时,在函数的最前面以关键字“inline”声明函数,即可是函数称为内联声明函数。(可以定义与声明时同时写inline,也可以只其中一处声明inline,效果相同,都能按照内联函数处理) Class A { ...
  • C语言之常用关键字的详解

    千次阅读 2016-09-12 17:53:24
    C语言中的常用关键字的一些看法和了解,以及它们的使用注意事项,
  • 当我们同时编译多个文件时,所有未static前缀的全局变量和函数都具有全局可见性。为理解这句话,我举例来说明。我们要同时编译两个源文件,一个是a.c,另一个是main.c。 下面是a.c的内容 chara='A';//...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 386,183
精华内容 154,473
关键字:

在函数说明前加关键字