1.函数名前加static关键字

函数就被定义成为静态函数。

函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。

定义静态函数的好处：

<1> 静态函数不能被其他文件所用。

<2> 其他文件中可以定义相同名字的函数，不会发生冲突。

<3> 静态函数会被自动分配在一个一直使用的存储区，直到退出应用程序实例，避免了调用函数时压栈出栈，速度快很多。



引申学习：

static变量与static函数

静态局部变量在函数内定义，生存期为整个源程序，但作用域为函数内。退出该函数后， 尽管该变量还继续存在，但不能使用它。

（对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。）

 
函数的定义以及关键字参数
 
4.6. 定义函数
4.7. 函数定义的更多形式
4.7.1. 参数默认值
4.7.2. 关键字参数
 

 
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

 
关于函数名前加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);
}

 

原文：https://blog.csdn.net/zqixiao_09/article/details/50877383
 
一、什么是内联函数
 
       在C语言中，如果一些函数被频繁调用，不断地有函数入栈，即函数栈，会造成栈空间或栈内存的大量消耗。
 
       为了解决这个问题，特别的引入了inline修饰符，表示为内联函数。
 
       栈空间就是指放置程式的局部数据也就是函数内数据的内存空间，在系统下，栈空间是有限的，假如频繁大量的使用就会造成因栈空间不足所造成的程式出错的问题，函数的死循环递归调用的最终结果就是导致栈内存空间枯竭。
 
下面我们来看一个例子：
 
 
 
 
#include <stdio.h> 
 
 
 
//函数定义为inline即:内联函数 
 
 
inline char* dbtest(int a) 
 
 
{ 
 
 
return (i % 2 > 0) ? "奇" : "偶"; 
 
 
} 
 
 
 
int main() 
 
 
{ 
 
 
int i = 0; 
 
 
for (i=1; i < 100; i++) 
 
 
{ 
 
 
printf("i:%d 奇偶性:%s /n", i, dbtest(i)); 
 
 
} 
 
 
} 
 
 
 
     上面的例子就是标准的内联函数的用法，使用inline修饰带来的好处我们表面看不出来，其实在内部的工作就是在每个for循环的内部任何调用dbtest(i)的地方都换成了(i%2>0)?"奇":"偶"这样就避免了频繁调用函数对栈内存重复开辟所带来的消耗。
 
     其实这种有点类似咱们前面学习的动态库和静态库的问题，使 dbtest 函数中的代码直接被放到main 函数中，执行for 循环时，会不断调用这段代码，而不是不断地开辟一个函数栈。
 
 
 
二、内联函数的编程风格
 
1、关键字inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用。
 
如下风格的函数Foo 不能成为内联函数：
 
 
 
 
inline void Foo(int x, int y); // inline 仅与函数声明放在一起
 
 
void Foo(int x, int y)
 
 
{
 
 
}
 
 
 
而如下风格的函数Foo 则成为内联函数：
 
 
 
 
void Foo(int x, int y);
 
 
inline void Foo(int x, int y) // inline 与函数定义体放在一起
 
 
{
 
 
}
 
       所以说，inline 是一种 “用于实现的关键字” ，而不是一种“用于声明的关键字”。一般地，用户可以阅读函数的声明，但是看不到函数的定义。尽管在大多数教科书中内联函数的声明、定义体前面都加了inline 关键字，但我认为inline 不应该出现在函数的声明中。这个细节虽然不会影响函数的功能，但是体现了高质量C++/C 程序设计风格的一个基本原则：声明与定义不可混为一谈，用户没有必要、也不应该知道函数是否需要内联。
 
 
 
 
 
2、inline的使用是有所限制的
 
      inline只适合涵数体内代码简单的函数数使用，不能包含复杂的结构控制语句例如while、switch，并且内联函数本身不能是直接递归函数(自己内部还调用自己的函数)。
 
 
 
三、慎用内联
 
       内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？如果所有的函数都是内联函数，还用得着“内联”这个关键字吗？
 
       内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收
 获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
 
以下情况不宜使用内联：
 
（1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
 
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
 
一个好的编译器将会根据函数的定义体，自动地取消不值得的内联（这进一步说明了inline 不应该出现在函数的声明中）。
 
 
 
总结：
 
       因此,将内联函数放在头文件里实现是合适的,省却你为每个文件实现一次的麻烦.而所以声明跟定义要一致,其实是指,如果在每个文件里都实现一次该内联函数的话,那么,最好保证每个定义都是一样的,否则,将会引起未定义的行为,即是说,如果不是每个文件里的定义都一样,那么,编译器展开的是哪一个,那要看具体的编译器而定.所以,最好将内联函数定义放在头文件中.