初中所学函数的定义　 内容详尽，但请以实际操作为准，欢迎下载使用
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
初中所学函数的定义　
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口当前位置：
＞＞＞定义：如果函数y=f（x）在定义域内给定区间[a，b]上存在x0（a＜x0＜b），..
定义：如果函数y=f（x）在定义域内给定区间[a，b]上存在x0（a＜x0＜b），满足f(x0)=f(b)-f(a)b-a，则称函数y=f（x）是[a，b]上的“平均值函数”，x0是它的一个均值点．如y=x4是[-1，1]上的平均值函数，0就是它的均值点．现有函数f（x）=-x2+mx+1是区间[-1，1]上的平均值函数，则实数m的取值范围是______．
题型：填空题难度：中档来源：不详
）∵函数f（x）=-x2+mx+1是区间[-1，1]上的平均值函数，∴关于x的方程-x2+mx+1=f(1)-f(-1)1-(-1)在（-1，1）内有实数根．由-x2+mx+1=f(1)-f(-1)1-(-1)=>x2-mx+m-1=0，解得x=m-1，x=1．又1?（-1，1）∴x=m-1必为均值点，即-1＜m-1＜1=>0＜m＜2．∴所求实数m的取值范围是0＜m＜2．故答案为：0＜m＜2．
马上分享给同学
据魔方格专家权威分析，试题“定义：如果函数y=f（x）在定义域内给定区间[a，b]上存在x0（a＜x0＜b），..”主要考查你对&&分段函数与抽象函数&&等考点的理解。关于这些考点的“档案”如下：
现在没空？点击收藏，以后再看。
因为篇幅有限，只列出部分考点，详细请访问。
分段函数与抽象函数
分段函数：1、分段函数：定义域中各段的x与y的对应法则不同，函数式是分两段或几段给出的； 分段函数是一个函数，定义域、值域都是各段的并集。&抽象函数：
我们把没有给出具体解析式的函数称为抽象函数； 一般形式为y=f（x），或许还附有定义域、值域等，如：y=f（x），（x＞0，y＞0）。 知识点拨：
1、绝对值函数去掉绝对符号后就是分段函数。 2、分段函数中的问题一般是求解析式、反函数、值域或最值，讨论奇偶性单调性等。 3、分段函数的处理方法：分段函数分段研究。
发现相似题
与“定义：如果函数y=f（x）在定义域内给定区间[a，b]上存在x0（a＜x0＜b），..”考查相似的试题有：
782796406090262055774510477440777618若对于定义在R上的连续函数f（x），存在常数a（a∈R），使得f（x+a）+af（x）=0对任意的实数x成立，则称f（x）是回旋函数，且阶数为a．（Ⅰ）试判断函数f（x）=x2是否是一个回旋函数；（Ⅱ）已知f（x）=sinωx是回旋函数，求实数ω的值；（Ⅲ）若对任意一个阶数为a的回旋函数f（x），方程f（x）=0均有实数根，求a的取值范围．【考点】．【专题】计算题．【分析】（Ⅰ）利用回旋函数的定义，令x=0，则必须有a=0；令x=1，则有a2+3a+1=0，故可判断；（Ⅱ）由于f（x）=sinwx是回旋函数，故有：sinw（x+a）+asinwx=0对任意实数x成立，从而可求实数ω的值；（Ⅲ）分类讨论是关键．a=0时结论显然；当a≠0时先假设存在，利用回旋函数的定义，易得在区间（0，a）上必有一个实根．【解答】解：（Ⅰ）若（x+a）2+ax2=0对任意实数都成立，令x=0，则必须有a=0令x=1，则有a2+3a+1=0，显然a=0不是这个方程的解故假设不成立，该函数不是回旋函数．（Ⅱ）由于f（x）=sinwx是回旋函数，故有：sinw（x+a）+asinwx=0对任意实数x成立令x=0，可得sinwa=0，令x=，可得coswa=-a，故a=±1，w=kπ（k为整数）（Ⅲ）如果a=0，显然f（x）=0，则显然有实根．下面考虑a≠0的情况．若存在实根x0，则f（x0+a）+af（x0）=0，即f（x0+a）=0说明实根如果存在，那么加a也是实根．因此在区间（0，a）上必有一个实根．则：f（0）f（a）＜0由于f（0+a）+af（0）=0，则f（0）=，只要a＞0，即可保证f（0）和f（a）异号．综上a≥0【点评】本题是新定义题，关键是理解新定义，利用新定义时，应注意赋值法的运用声明：本试题解析著作权属菁优网所有，未经书面同意，不得复制发布。答题：　难度：0.45真题：1组卷：0
解析质量好中差Python 里为什么函数可以返回一个函数内部定义的函数？
Python 初学。&br&看@函数修饰符的例子。看到一个这样的例子&br&&div class=&highlight&&&pre&&code class=&language-python&&&span class=&k&&def&/span& &span class=&nf&&spamrun&/span&&span class=&p&&(&/span&&span class=&n&&fn&/span&&span class=&p&&):&/span&
&span class=&k&&def&/span& &span class=&nf&&sayspam&/span&&span class=&p&&(&/span&&span class=&o&&*&/span&&span class=&n&&args&/span&&span class=&p&&):&/span&
&span class=&k&&print&/span& &span class=&s&&&spam,spam,spam&&/span&
&span class=&k&&return&/span& &span class=&n&&sayspam&/span&
&/code&&/pre&&/div&&br&内部定义的函数可以作为返回值……内部这个函数的是不是被复制了一份然后返回给外部了……是不是可以这样理解：&br&&div class=&highlight&&&pre&&code class=&language-python&&&span class=&k&&def&/span& &span class=&nf&&spamrun&/span&&span class=&p&&(&/span&&span class=&n&&fn&/span&&span class=&p&&):&/span&
&span class=&n&&f&/span& &span class=&o&&=&/span& &span class=&k&&lambda&/span& &span class=&n&&args&/span&&span class=&p&&:&/span&&span class=&k&&print&/span& &span class=&s&&&spam,spam,spam&&/span&
&span class=&k&&return&/span& &span class=&n&&f&/span&
&/code&&/pre&&/div&&br&我想百度相关的知识的，找了半天没有找到，“函数内部定义函数”这样的关键字没有找到想要的答案。求懂的人指导。&br&&br&------------------------------------修改补充----------------------------&br&&div class=&highlight&&&pre&&code class=&language-python&&&span class=&k&&def&/span& &span class=&nf&&addspam&/span&&span class=&p&&(&/span&&span class=&n&&fn&/span&&span class=&p&&):&/span&
&span class=&k&&def&/span& &span class=&nf&&new&/span&&span class=&p&&(&/span&&span class=&o&&*&/span&&span class=&n&&args&/span&&span class=&p&&):&/span&
&span class=&k&&print&/span& &span class=&s&&&spam,spam,spam&&/span&
&span class=&k&&return&/span& &span class=&n&&fn&/span&&span class=&p&&(&/span&&span class=&o&&*&/span&&span class=&n&&args&/span&&span class=&p&&)&/span&
&span class=&k&&return&/span& &span class=&n&&new&/span&
&span class=&nd&&@addspam&/span&
&span class=&k&&def&/span& &span class=&nf&&useful&/span&&span class=&p&&(&/span&&span class=&n&&a&/span&&span class=&p&&,&/span&&span class=&n&&b&/span&&span class=&p&&):&/span&
&span class=&k&&print&/span& &span class=&n&&a&/span&&span class=&o&&**&/span&&span class=&mi&&2&/span&&span class=&o&&+&/span&&span class=&n&&b&/span&&span class=&o&&**&/span&&span class=&mi&&2&/span&
&/code&&/pre&&/div&&br&&br&理解执行 useful(3, 4) 相当于：&br&&br&useful(3,4)
--& addspam（useful(3,4)）--&&br&&br&到这里就不知道怎么理解好了。addspam 返回了一个new，而 new 用到了addspam 传入的参数，即 useful(3, 4)，但是 new 的形参是怎么给值的呢……所以 new 里执行的 fn(*args) 的 args 是怎么给的。看输出结果就是执行了 useful(3, 4)。只是不明白3,4怎么就给到了 *args。
Python 初学。看@函数修饰符的例子。看到一个这样的例子def spamrun(fn):
def sayspam(*args):
print "spam,spam,spam"
return sayspam
内部定义的函数可以作为返回值……内部这个函数的是不是被复制了一份然后返回给外部了……是不是可以这样理解：def spamrun(fn):
f = lambda args:print "spam,spam,spam"
我想百度相关的知识的，找了半天没有找到，“函数内部定义函数”这样的关键字没有找到想要的答案。求懂的人指导。------------------------------------修改补充----------------------------def addspam(fn):
def new(*args):
print "spam,spam,spam"
return fn(*args)
return new
def useful(a,b):
print a**2+b**2…
按投票排序
题主可能并没有理解“在Python中，函数本身也是对象”这一本质。那不妨慢慢来，从最基本的概念开始，讨论一下这个问题：1. Python中一切皆对象这恐怕是学习Python最有用的一句话。想必你已经知道Python中的list, tuple, dict等内置数据结构，当你执行：alist = [1, 2, 3]
时，你就创建了一个列表对象，并且用alist这个变量引用它：当然你也可以自己定义一个类:当然你也可以自己定义一个类:class House(object):
def __init__(self, area, city):
self.area = area
self.city = city
def sell(self, price):
#other code
return price
然后创建一个类的对象：house = House(200, 'Shanghai')
OK，你立马就在上海有了一套200平米的房子，它有一些属性(area, city)，和一些方法(__init__, self)：2. 函数是第一类对象和list, tuple, dict以及用House创建的对象一样，当你定义一个函数时，函数也是对象：def func(a, b):
return a+b
在全局域，函数对象被函数名引用着，它接收两个参数a和b，计算这两个参数的和作为返回值。在全局域，函数对象被函数名引用着，它接收两个参数a和b，计算这两个参数的和作为返回值。所谓第一类对象，意思是可以用标识符给对象命名，并且对象可以被当作数据处理，例如赋值、作为参数传递给函数，或者作为返回值return 等因此，你完全可以用其他变量名引用这个函数对象：add = func
这样，你就可以像调用func(1, 2)一样，通过新的引用调用函数了：这样，你就可以像调用func(1, 2)一样，通过新的引用调用函数了：print func(1, 2)
print add(1, 2)
#the same as func(1, 2)
或者将函数对象作为参数，传递给另一个函数：def caller_func(f):
return f(1, 2)
if __name__ == "__main__":
print caller_func(func)
可以看到，函数对象func作为参数传递给caller_func函数，传参过程类似于一个赋值操作f=func；于是func函数对象，被caller_func函数作用域中的局部变量f引用，f实际指向了函数func；cc当执行return f(1, 2)的时候，相当于执行了return func(1, 2)；因此输出结果为3。3. 函数对象 vs 函数调用无论是把函数赋值给新的标识符，还是作为参数传递给新的函数，针对的都是函数对象本身，而不是函数的调用。用一个更加简单，但从外观上看，更容易产生混淆的例子来说明这个问题。例如定义了下面这个函数：def func():
return "hello,world"
然后分别执行两次赋值：ref1 = func
#将函数对象赋值给ref1
ref2 = func()
#调用函数，将函数的返回值("hello,world"字符串)赋值给ref2
很多初学者会混淆这两种赋值，通过Python内建的type函数，可以查看一下这两次赋值的结果：In [4]: type(ref1)
Out[4]: function
In [5]: type(ref2)
Out[5]: str
可以看到，ref1引用了函数对象本身，而ref2则引用了函数的返回值。通过内建的callable函数，可以进一步验证ref1是可调用的，而ref2是不可调用的：In [9]: callable(ref1)
Out[9]: True
In [10]: callable(ref2)
Out[10]: False
传参的效果与之类似。4. 闭包&LEGB法则所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象听上去的确有些复杂，还是用一个栗子来帮助理解一下。假设我们在foo.py模块中做了如下定义：#foo.py
filename = "foo.py"
def call_func(f):
return f()
#如前面介绍的，f引用一个函数对象，然后调用它
在另一个func.py模块中，写下了这样的代码：#func.py
import foo
#导入foo.py
filename = "func.py"
def show_filename():
return "filename: %s" % filename
if __name__ == "__main__":
print foo.call_func(show_filename)
#注意：实际发生调用的位置，是在foo.call_func函数中
当我们用python func.py命令执行func.py时输出结果为：chiyu@chiyu-PC:~$ python func.py
filename:func.py
很显然show_filename()函数使用的filename变量的值，是在与它相同环境(func.py模块)中定义的那个。尽管foo.py模块中也定义了同名的filename变量，而且实际调用show_filename的位置也是在foo.py的call_func内部。而对于嵌套函数，这一机制则会表现的更加明显：闭包将会捕捉内层函数执行所需的整个环境：#enclosed.py
import foo
def wrapper():
filename = "enclosed.py"
def show_filename():
return "filename: %s" % filename
print foo.call_func(show_filename)
#输出：filename: enclosed.py
实际上，每一个函数对象，都有一个指向了该函数定义时所在全局名称空间的__globals__属性：#show_filename inside wrapper
#show_filename.__globals__
'__builtins__': &module '__builtin__' (built-in)&,
#内建作用域环境
'__file__': 'enclosed.py',
'wrapper': &function wrapper at 0x7f&,
#直接外围环境
'__package__': None,
'__name__': '__main__',
'foo': &module 'foo' from '/home/chiyu/foo.pyc'&,
'__doc__': None
当代码执行到show_filename中的return "filename: %s" % filename语句时，解析器按照下面的顺序查找filename变量：Local - 本地函数(show_filename)内部，通过任何方式赋值的，而且没有被global关键字声明为全局变量的filename变量；Enclosing - 直接外围空间(上层函数wrapper)的本地作用域，查找filename变量(如果有多层嵌套，则由内而外逐层查找，直至最外层的函数)；Global - 全局空间(模块enclosed.py)，在模块顶层赋值的filename变量；Builtin - 内置模块(__builtin__)中预定义的变量名中查找filename变量；在任何一层先找到了符合要求的filename变量，则不再向更外层查找。如果直到Builtin层仍然没有找到符合要求的变量，则抛出NameError异常。这就是变量名解析的：LEGB法则。总结：闭包最重要的使用价值在于：封存函数执行的上下文环境；闭包在其捕捉的执行环境(def语句块所在上下文)中，也遵循LEGB规则逐层查找，直至找到符合要求的变量，或者抛出异常。5. 装饰器&语法糖(syntax sugar)那么闭包和装饰器又有什么关系呢？上文提到闭包的重要特性：封存上下文，这一特性可以巧妙的被用于现有函数的包装，从而为现有函数更加功能。而这就是装饰器。还是举个例子，代码如下：#alist = [1, 2, 3, ..., 100]
--& 1+2+3+...+100 = 5050
def lazy_sum():
return reduce(lambda x, y: x+y, alist)
我们定义了一个函数lazy_sum，作用是对alist中的所有元素求和后返回。alist假设为1到100的整数列表：alist = range(1, 101)
但是出于某种原因，我并不想马上返回计算结果，而是在之后的某个地方，通过显示的调用输出结果。于是我用一个wrapper函数对其进行包装：def wrapper():
alist = range(1, 101)
def lazy_sum():
return reduce(lambda x, y: x+y, alist)
return lazy_sum
lazy_sum = wrapper()
#wrapper() 返回的是lazy_sum函数对象
if __name__
== "__main__":
lazy_sum()
这是一个典型的Lazy Evaluation的例子。我们知道，一般情况下，局部变量在函数返回时，就会被垃圾回收器回收，而不能再被使用。但是这里的alist却没有，它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确，实际是包含在了lazy_sum的执行环境中，通过__globals__)，从而延长了生命周期。当在if语句块中调用lazy_sum()的时候，解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表，计算结果，返回5050。当你需要动态的给已定义的函数增加功能时，比如：参数检查，类似的原理就变得很有用：def add(a, b):
return a+b
这是很简单的一个函数：计算a+b的和返回，但我们知道Python是 动态类型+强类型 的语言，你并不能保证用户传入的参数a和b一定是两个整型，他有可能传入了一个整型和一个字符串类型的值：In [2]: add(1, 2)
In [3]: add(1.2, 3.45)
Out[3]: 4.65
In [4]: add(5, 'hello')
---------------------------------------------------------------------------
Traceback (most recent call last)
/home/chiyu/&ipython-input-4-f2f9e8aa5eae& in &module&()
----& 1 add(5, 'hello')
/home/chiyu/&ipython-input-1-02b3d3d6caec& in add(a, b)
1 def add(a, b):
return a+b
TypeError: unsupported operand type(s) for +: 'int' and 'str'
于是，解析器无情的抛出了一个TypeError异常。动态类型：在运行期间确定变量的类型，python确定一个变量的类型是在你第一次给他赋值的时候；强类型：有强制的类型定义，你有一个整数，除非显示的类型转换，否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做+运算)；因此，为了更加优雅的使用add函数，我们需要在执行+运算前，对a和b进行参数检查。这时候装饰器就显得非常有用：import logging
logging.basicConfig(level = logging.INFO)
def add(a, b):
return a + b
def checkParams(fn):
def wrapper(a, b):
if isinstance(a, (int, float)) and isinstance(b, (int, float)):
#检查参数a和b是否都为整型或浮点型
return fn(a, b)
#是则调用fn(a, b)返回计算结果
#否则通过logging记录错误信息，并友好退出
logging.warning("variable 'a' and 'b' cannot be added")
return wrapper
#fn引用add，被封存在闭包的执行环境中返回
if __name__ == "__main__":
#将add函数对象传入，fn指向add
#等号左侧的add，指向checkParams的返回值wrapper
add = checkParams(add)
add(3, 'hello')
#经过类型检查，不会计算结果，而是记录日志并退出
注意checkParams函数：首先看参数fn，当我们调用checkParams(add)的时候，它将成为函数对象add的一个本地(Local)引用；在checkParams内部，我们定义了一个wrapper函数，添加了参数类型检查的功能，然后调用了fn(a, b)，根据LEGB法则，解释器将搜索几个作用域，并最终在(Enclosing层)checkParams函数的本地作用域中找到fn；注意最后的return wrapper，这将创建一个闭包，fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中，不会随着checkParams的返回而被回收；当调用add = checkParams(add)时，add指向了新的wrapper对象，它添加了参数检查和记录日志的功能，同时又能够通过封存的fn，继续调用原始的add进行+运算。因此调用add(3, 'hello')将不会返回计算结果，而是打印出日志：chiyu@chiyu-PC:~$ python func.py
WARNING:root:variable 'a' and 'b' cannot be added
有人觉得add = checkParams(add)这样的写法未免太过麻烦，于是python提供了一种更优雅的写法，被称为语法糖：@checkParams
def add(a, b):
return a + b
这只是一种写法上的优化，解释器仍然会将它转化为add = checkParams(add)来执行。6. 回归问题def addspam(fn):
def new(*args):
print "spam,spam,spam"
return fn(*args)
return new
def useful(a,b):
print a**2+b**2
首先看第二段代码：@addspam装饰器，相当于执行了useful = addspam(useful)。在这里题主有一个理解误区：传递给addspam的参数，是useful这个函数对象本身，而不是它的一个调用结果；再回到addspam函数体：return new 返回一个闭包，fn被封存在闭包的执行环境中，不会随着addspam函数的返回被回收；而fn此时是useful的一个引用，当执行return fn(*args)时，实际相当于执行了return useful(*args)；最后附上一张代码执行过程中的引用关系图，希望能帮助你理解：
Python里面的@只是一个syntax sugar而已，在你声明useful的时候，interpreter检查到你有外面有装饰器@addspam的存在，这时候你就可以大致理解成解释器做了以下的手脚：useful = addspam(useful)
所以你以后调用useful的时候，你调用的其实是new，不信可以看一下这个useful.__name__，已经变成new了。到了这里就没有addspam什么事情了。
题主遇到的这个问题很典型，就是把修饰器当成了包装器, 认为调用 useful 前先调用 addspam。其实 useful 不是被 addspam 包装了，而是替换了。调用 useful 调用的就是 new。余下的 fn 指向原来的 useful, 才需要第一类函数、作用域继承等知识点来理解。可变参数 *args 则是干扰的另外一个知识点，替换成 x, y 就行了。
Python中，函数并没有什么特殊的，就是一个对象。
很好的问题！请搜索higher order functions了解更多信息。因为我没有能力来清楚地解释，就放几篇我在学习函数式编程的时候看到的比较好的博文来帮助你理解。我喜欢最后一篇文章，通过实例来理解效果更好。
你没理解修饰器。用addspam修饰了useful后，你应该理解为这个函数变成了new。当调用useful函数的时候，其实是调用了new。
不是简单地返回函数。至少在Python里，def定义的函数和lambda定义的函数，后者是包含closure的。具体closure是什么，这真不是一句话能说清，我也不觉得我能说好，所以还是自己搜一下吧。不要说我歧视用百度查这种问题，这去Google搜个nested functions多好。
没有复制，函数也是个对象，基本就和你 return 一个 list 一个 dict 没什么两样。试试看在 Python REPL 中创建一个 function:&&& def foobar(): print("你好")
&&& foobar
&&& func_list = [foobar, foobar, foobar]
&&& func_list[0]()
后者是一个闭包 ( closure )，简单来说就是函数对象中包装了函数中引用的外部变量，可以想象成这个函数被动态创建的时候，引用的外部变量冻结在函数里面了。你新补充的我没怎么看懂，*args 的作用吗？*args 在形参上的作用类似捕获给函数的实参放在一个 args 的表中作为形参，如果作为实参传入的话，就是将 args 这个表解开作为分别的形参输入。
看完就明白了新手园地& & & 硬件问题Linux系统管理Linux网络问题Linux环境编程Linux桌面系统国产LinuxBSD& & & BSD文档中心AIX& & & 新手入门& & & AIX文档中心& & & 资源下载& & & Power高级应用& & & IBM存储AS400Solaris& & & Solaris文档中心HP-UX& & & HP文档中心SCO UNIX& & & SCO文档中心互操作专区IRIXTru64 UNIXMac OS X门户网站运维集群和高可用服务器应用监控和防护虚拟化技术架构设计行业应用和管理服务器及硬件技术& & & 服务器资源下载云计算& & & 云计算文档中心& & & 云计算业界& & & 云计算资源下载存储备份& & & 存储文档中心& & & 存储业界& & & 存储资源下载& & & Symantec技术交流区安全技术网络技术& & & 网络技术文档中心C/C++& & & GUI编程& & & Functional编程内核源码& & & 内核问题移动开发& & & 移动开发技术资料ShellPerlJava& & & Java文档中心PHP& & & php文档中心Python& & & Python文档中心RubyCPU与编译器嵌入式开发驱动开发Web开发VoIP开发技术MySQL& & & MySQL文档中心SybaseOraclePostgreSQLDB2Informix数据仓库与数据挖掘NoSQL技术IT业界新闻与评论IT职业生涯& & & 猎头招聘IT图书与评论& & & CU技术图书大系& & & Linux书友会二手交易下载共享Linux文档专区IT培训与认证& & & 培训交流& & & 认证培训清茶斋投资理财运动地带快乐数码摄影& & & 摄影器材& & & 摄影比赛专区IT爱车族旅游天下站务交流版主会议室博客SNS站务交流区CU活动专区& & & Power活动专区& & & 拍卖交流区频道交流区
空间积分2 信誉积分8 UID阅读权限10积分50帖子精华可用积分52 专家积分0 在线时间316 小时注册时间最后登录
白手起家, 积分 50, 距离下一级还需 150 积分
帖子主题精华可用积分52 专家积分0 在线时间316 小时注册时间最后登录
论坛徽章:0
有几个疑问：
1.在头文件中定义inline函数是可以的，可为什么不能在头文件中定义普通的函数呢？不是说inline仅仅是
对编译器的建议吗？如果被编译器忽略了呢，那不跟普通函数一样了吗？
2.在头文件声明函数，cpp文件中定义函数很好理解，在头文件中定义类也很好理解。至于在头文件中定义
函数，为什么会有这种需求呢？我代码写得少，读的少，想不清楚。
3.这些问题的答案，也就是说这样的用法到底合不合法，肯定基于一个准则吧，这个准则是什么呢？哪本书
或资料里有介绍呢？希望从根本上得到个解释~
screen.width*0.7) {this.resized= this.width=screen.width*0.7; this.alt='Click here to open new window\nCTRL+Mouse wheel to zoom in/out';}" onmouseover="if(this.width>screen.width*0.7) {this.resized= this.width=screen.width*0.7; this.style.cursor='hand'; this.alt='Click here to open new window\nCTRL+Mouse wheel to zoom in/out';}" onclick="if(!this.resized) {} else {window.open(this.src);}" onmousewheel="return imgzoom(this);" alt="" />
&&nbsp|&&nbsp&&nbsp|&&nbsp&&nbsp|&&nbsp&&nbsp|&&nbsp
空间积分0 信誉积分38 UID阅读权限70积分5045帖子精华可用积分5047 专家积分48 在线时间847 小时注册时间最后登录
富足长乐, 积分 5045, 距离下一级还需 2955 积分
帖子主题精华可用积分5047 专家积分48 在线时间847 小时注册时间最后登录
论坛徽章:0
1.你想在头文件中定义普通函数也可以，没人拦着你
至于inline函数，因为在编译的过程中就要进行“替换”，所以你必须要定义在头文件中并且也要include，不然编译器怎么知道这个inline函数是啥？当然你直接把这个inline函数实现的.c给include了也可以。至于普通的函数，是在链接过程中resolve的，所以不存在这个问题，在头文件中只需要有declaration就可以了。没有declaration的话c也是可以，但是很危险，因为这样的话编译器就不能帮你做函数类型检查了（比如说形参个数，返回类型），而且对于没有声明过的函数，gcc会帮你implicit推断出一个返回值为int的函数，这在有些情况下是相当危险的。这部分你可以去看看函数的argument passing以及调用的过程。
一句话，你需要理解编译和链接这两个过程都干了点什么？
比较好的著作你去看看hacking helloworld，一个台湾人写的文章
其实我只是一架人肉搜索引擎
空间积分0 信誉积分1419 UID阅读权限50积分3469帖子精华可用积分3469 专家积分0 在线时间5689 小时注册时间最后登录
小富即安, 积分 3469, 距离下一级还需 1531 积分
帖子主题精华可用积分3469 专家积分0 在线时间5689 小时注册时间最后登录
论坛徽章:8
先回答这个问题吧：
3.这些问题的答案，也就是说这样的用法到底合不合法，肯定基于一个准则吧，这个准则是什么呢？哪本书
或资料里有介绍呢？希望从根本上得到个解释~
首先要知道如下两点：
1、扩展名不提供任何功能。
所以，技术上根本不需要区分何谓头文件、何谓实现文件。
所谓include，其实就是指示编译器，让它把指定文件的内容拷贝过来，把 #include 那一行给覆盖了。
所以，可以认为，最终给编译器看到的东西里面，include是不存在的，只有单纯的函数原型声明，可能还有部分或者全部这些函数的实现。
这样一份已经被整合过的文件，就叫做一个编译单元。它最终对应一个.o文件（windows下是.ｏｂｊ）。
下一步就可以用链接器把所有这些编译单元、静态库以及动态库统统链接起来，形成可执行文件或者库。
2、如上，想象一下，如果一个很大的项目，没有规矩，谁想包含谁都可以，这样东拉西扯下来会出现什么？
显然，首先是程序不敢改了。一改别人的文件也跟着变，这哪受得了。
其次，程序很难编译成功。因为这个.o文件里有函数A的实现，那个.o文件里也有函数A的实现，链接器哭了：我究竟该以谁为准啊。
最糟糕的时候，还可能出现循环依赖，甚至是包含关系死循环。
所以，程序界哪些聪明的先行者们就约定，大家都把文件分两种，一种叫头文件，只声明接口，不准写实现代码，这样只要接口名字不冲突头文件就可以随便包含；另一种叫实现文件，实现文件里就随便搞了；但必须注意，任何人都不准包含实现文件——否则链接器就又要哭了。
了解了以上基础，你的这些问题就很好回答了：
1.在头文件中定义inline函数是可以的，可为什么不能在头文件中定义普通的函数呢？不是说inline仅仅是
对编译器的建议吗？如果被编译器忽略了呢，那不跟普通函数一样了吗？
inline的含义本身，就是“让编译器把删掉了call/return过程的实现代码弄得到处都是”，但如果编译器无法inline，那么它就还原成函数调用。
比如，一个虚函数能不能inline？为什么？
2.在头文件声明函数，cpp文件中定义函数很好理解，在头文件中定义类也很好理解。至于在头文件中定义
函数，为什么会有这种需求呢？我代码写得少，读的少，想不清楚。
没有在头文件里定义函数的需求。原因如上所述。
注意一个特殊情况： STL相当于一种智能宏，它会根据参数自动生成代码。
但没有模板参数怎么办？
所以，STL实现不能当作独立的编译单元，它必须被其他.c文件包含、并提供模板参数之后、才有可能得到真正的实现代码。
所以，严格的说，STL的实现其实也是一种声明。这里面的技术细节更多，不过我们这些不写通用库的人就不需要追究了。
[ 本帖最后由 shan_ghost 于
18:06 编辑 ]
空间积分2 信誉积分8 UID阅读权限10积分50帖子精华可用积分52 专家积分0 在线时间316 小时注册时间最后登录
白手起家, 积分 50, 距离下一级还需 150 积分
帖子主题精华可用积分52 专家积分0 在线时间316 小时注册时间最后登录
论坛徽章:0
恩，讲解的比较详细，谢谢两位~
screen.width*0.7) {this.resized= this.width=screen.width*0.7; this.alt='Click here to open new window\nCTRL+Mouse wheel to zoom in/out';}" onmouseover="if(this.width>screen.width*0.7) {this.resized= this.width=screen.width*0.7; this.style.cursor='hand'; this.alt='Click here to open new window\nCTRL+Mouse wheel to zoom in/out';}" onclick="if(!this.resized) {} else {window.open(this.src);}" onmousewheel="return imgzoom(this);" alt="" />
空间积分0 信誉积分100 UID阅读权限20积分240帖子精华可用积分240 专家积分0 在线时间140 小时注册时间最后登录
稍有积蓄, 积分 240, 距离下一级还需 260 积分
帖子主题精华可用积分240 专家积分0 在线时间140 小时注册时间最后登录
论坛徽章:0
3楼 是老师吧 回答的思路井井有条 让人看了很容易接受.
论坛能有您在 菜鸟们真有福气啊.:wink:
北京皓辰网域网络信息技术有限公司. 版权所有 京ICP证:060528号 北京市公安局海淀分局网监中心备案编号：
广播电视节目制作经营许可证(京) 字第1234号
中国互联网协会会员&&联系我们：
感谢所有关心和支持过ChinaUnix的朋友们
转载本站内容请注明原作者名及出处