1.  内联函数
在C++中我们通常定义以下函数来求两个整数的最大值：
复制代码 代码如下:


int max(int a, int b)

{

 return a > b ? a : b;

}

为这么一个小的操作定义一个函数的好处有：
① 阅读和理解函数 max 的调用，要比读一条等价的条件表达式并解释它的含义要容易得多
② 如果需要做任何修改，修改函数要比找出并修改每一处等价表达式容易得多
③ 使用函数可以确保统一的行为，每个测试都保证以相同的方式实现
④ 函数可以重用，不必为其他应用程序重写代码
虽然有这么多好处，但是写成函数有一个潜在的缺点：调用函数比求解等价表达式要慢得多。在大多数的机器上，调用函数都要做很多工作：调用前要先保存寄存器，并在返回时恢复，复制实参，程序还必须转向一个新位置执行
C++中支持内联函数，其目的是为了提高函数的执行效率，用关键字 inline 放在函数定义(注意是定义而非声明，下文继续讲到)的前面即可将函数指定为内联函数，内联函数通常就是将它在程序中的每个调用点上“内联地”展开，假设我们将 max 定义为内联函数：
复制代码 代码如下:


inline int max(int a, int b)

{

 return a > b ? a : b;

}

则调用： cout<<max(a, b)<<endl;


在编译时展开为： cout<<(a > b ? a : b)<<endl;
从而消除了把 max写成函数的额外执行开销
2.  内联函数和宏
无论是《Effective C++》中的 “Prefer consts，enums，and inlines to #defines” 条款，还是《高质量程序设计指南——C++/C语言》中的“用函数内联取代宏”，宏在C++中基本是被废了，在书《高质量程序设计指南——C++/C语言》中这样解释到：

3.  将内联函数放入头文件
关键字 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 与函数定义体放在一起

{

 ...

} 

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


class A

{  

public:

 void Foo(int x, int y) { ... }   // 自动地成为内联函数  

} 

但是编译器是否将它真正内联则要看 Foo函数如何定义
内联函数应该在头文件中定义，这一点不同于其他函数。编译器在调用点内联展开函数的代码时，必须能够找到 inline 函数的定义才能将调用函数替换为函数代码，而对于在头文件中仅有函数声明是不够的。
当然内联函数定义也可以放在源文件中，但此时只有定义的那个源文件可以用它，而且必须为每个源文件拷贝一份定义(即每个源文件里的定义必须是完全相同的)，当然即使是放在头文件中，也是对每个定义做一份拷贝，只不过是编译器替你完成这种拷贝罢了。但相比于放在源文件中，放在头文件中既能够确保调用函数是定义是相同的，又能够保证在调用点能够找到函数定义从而完成内联(替换)。
但是你会很奇怪，重复定义那么多次，不会产生链接错误？
我们来看一个例子：
A.h :
复制代码 代码如下:


class A

{

public:

 A(int a, int b) : a(a),b(b){}

 int max();
private:

 int a;

 int b;

};


A.cpp : 

复制代码 代码如下:


#include "A.h"
inline int A::max()

{

 return a > b ? a : b;

}


Main.cpp : 

复制代码 代码如下:


#include <iostream>

#include "A.h"

using namespace std;
inline int A::max()

{

 return a > b ? a : b;

}
int main()

{

 A a(3, 5);

 cout<<a.max()<<endl;

 return 0;

}


一切正常编译，输出结果：5
 


倘若你在Main.cpp中没有定义max内联函数，那么会出现链接错误：
error LNK2001: unresolved external symbol "public: int __thiscall A::max(void)" (?max@A@@QAEHXZ)main.obj

找不到函数的定义，所以内联函数可以在程序中定义不止一次，只要 inline 函数的定义在某个源文件中只出现一次，而且在所有源文件中，其定义必须是完全相同的就可以。
在头文件中加入或修改 inline 函数时，使用了该头文件的所有源文件都必须重新编译。
4.  慎用内联
内联虽有它的好处，但是也要慎用，以下摘自《高质量程序设计指南——C++/C语言》：

而在Google C++编码规范中则规定得更加明确和详细：
内联函数：
Tip： 只有当函数只有 10 行甚至更少时才将其定义为内联函数.
定义: 当函数被声明为内联函数之后, 编译器会将其内联展开, 而不是按通常的函数调用机制进行调用.

优点: 当函数体比较小的时候, 内联该函数可以令目标代码更加高效. 对于存取函数以及其它函数体比较短, 性能关键的函数, 鼓励使用内联.

缺点: 滥用内联将导致程序变慢. 内联可能使目标代码量或增或减, 这取决于内联函数的大小. 内联非常短小的存取函数通常会减少代码大小, 但内联一个相当大的函数将戏剧性的增加代码大小. 现代处理器由于更好的利用了指令缓存, 小巧的代码往往执行更快。

结论: 一个较为合理的经验准则是, 不要内联超过 10 行的函数. 谨慎对待析构函数, 析构函数往往比其表面看起来要更长, 因为有隐含的成员和基类析构函数被调用!

另一个实用的经验准则: 内联那些包含循环或 switch 语句的函数常常是得不偿失 (除非在大多数情况下, 这些循环或 switch 语句从不被执行).

有些函数即使声明为内联的也不一定会被编译器内联, 这点很重要; 比如虚函数和递归函数就不会被正常内联. 通常, 递归函数不应该声明成内联函数.(递归调用堆栈的展开并不像循环那么简单, 比如递归层数在编译时可能是未知的, 大多数编译器都不支持内联递归函数). 虚函数内联的主要原因则是想把它的函数体放在类定义内, 为了图个方便, 抑或是当作文档描述其行为, 比如精短的存取函数.
-inl.h文件：


Tip： 复杂的内联函数的定义, 应放在后缀名为 -inl.h 的头文件中.


内联函数的定义必须放在头文件中, 编译器才能在调用点内联展开定义. 然而, 实现代码理论上应该放在 .cc 文件中, 我们不希望 .h 文件中有太多实现代码, 除非在可读性和性能上有明显优势.
如果内联函数的定义比较短小, 逻辑比较简单, 实现代码放在 .h 文件里没有任何问题. 比如, 存取函数的实现理所当然都应该放在类定义内. 出于编写者和调用者的方便, 较复杂的内联函数也可以放到 .h 文件中, 如果你觉得这样会使头文件显得笨重, 也可以把它萃取到单独的 -inl.h 中. 这样把实现和类定义分离开来, 当需要时包含对应的 -inl.h 即可。





顶

2

我们先复习下什么是函数：函数是发生在集合之间的一种对应关系(我喜欢用图理解) 数据库中讨论得比较多是非平凡函数依赖，而平凡意义不大) 因为成绩不是(学号，课程)的子集。 部分函数依赖：(学号，姓名)→ 性别 因为(学号，姓名)→ 性别 且 学号 →
我们先复习下什么是函数：函数是发生在集合之间的一种对应关系(我喜欢用图理解)
数据库中讨论得比较多是非平凡函数依赖，而平凡意义不大)
因为成绩不是(学号，课程)的子集。
部分函数依赖：(学号，姓名)→ 性别
因为(学号，姓名)→ 性别 且 学号 → 性别
完全函数依赖：(学号，课程号)→ 成绩
因为(学号，课程号)→ 成绩，学号 —\→ 成绩，课程号 —\→ 成绩。
传递函数依赖： 学号 → 系主任
因为学号 → 系名，系名 → 系主任 且 系名 —\→ 学号。
而多值依赖呢？给出定义
多值依赖的定义：
设R(U)是一个属性集合U上的一个关系模式，X, Y, 和Z是U的子集，并且Z=U-X-Y，多值依赖X->->Y成立当且仅当对R的任一个关系r，r在(X,Z)上的每个值对应一组Y的值，这组值仅仅决定于X值而与Z值无关。
若X->->Y，而Z=空集，则称X->->Y为平凡的多值依赖。否则，称X->->Y为非平凡的多值依赖。
依然用函数的映射关系来理解，引入f(x，y)，假设f(x，y)=+-(x^)，若z=f(x，y)，则一个x值可以得出两个互为相反数的z。在这个二元函数关系中，y的取值事实上是不影响结果的。类比到关系模式上，即x为X集的属性值，y为Y集的属性值，z为Z集的属性值。
看看一个例子
(课程C) ——(教师T)—(参考书B)
数据库概率 —顾国生老师——数学分析
数据库概率 —顾国生老师——高等代数
数据库概率 —顾国生老师——微分方程
上述例子U{C,T,B},其中课程C和教师T唯一确定一组B，却与T无关，经由C决定，然而T并不是空集，所以是非平凡的多值依赖。
事实上，当T为空的时候，如果C中的每一个值c对应B中的一个确定的值，则变为函数依赖，所以函数依赖是多值依赖的一种特殊情况。
总计下：
1. 函数依赖不是指关系模式R的某个或某些关系实例满足的约束条件，而是指R的所有关系实例均要满足的约束条件。
2. 函数依赖是语义范畴的概念。只能根据数据的语义来确定函数依赖。(例如“姓名→年龄”这个函数依赖只有在不允许有同名人的条件下成立)
3. 函数依赖通常以集合抽闲出来讨论。
4. 数据库设计者根据需求对函数关系进行制定。例如认为“姓名→年龄”在特定表中可行。
5. 数据库设计者根据现实规定做强制要求。例如规定不允许同名人出现，函数依赖“姓名→年龄”成立。所插入的元组必须满足规定
的函数依赖，若发现有同名人存在， 则拒绝装入该元组。
本文原创发布php中文网，转载请注明出处，感谢您的尊重！

之前小编给大家介绍了用python去返回了一个值，立马就有小伙伴跟小编留言说道“能都执行多个内容？”于是，小编就给大家整理最细致，也是最简单的实现方法，方便大家理解学习，一起来看下吧~
直接上代码，多线程同时执行多个函数代码如下：import time
import os
import threading
def open_calc():
with open('test.txt', 'r') as f:
for line in f.readlines():
while 'hello' in line:
os.system("calc.exe")
# 如果字符串已经出现并已经执行命令，则终止程序，否则会一直执行命令
return
# 等for循环判断完没有标识后再休眠重新调用该函数
print('没有找到启动标识：hello，等5秒再检测')
time.sleep(5)
# 再次调用函数
open_calc()
def open_mstsc():
with open('test.txt', 'r') as f:
for line in f.readlines():
while 'abc' in line:
os.system("mstsc.exe")
# 如果字符串已经出现并已经执行命令，则终止程序，否则会一直执行命令
return
# 等for循环判断完没有标识后再休眠重新调用该函数
print('没有找到启动标识：abc，等6秒再检测')
time.sleep(6)
# 再次调用函数
open_mstsc()
if __name__ == '__main__':
# 使用threading模块，threading.Thread()创建线程，其中target参数值为需要调用的方法，同样将其他多个线程放在一个列表中，遍历这个列表就能同时执行里面的函数了
threads = [threading.Thread(target=open_calc),
threading.Thread(target=open_mstsc)]
for t in threads:
# 启动线程
t.start()
知识拓展——多线程
l使用threading模块里面的Thread类创建出实例对象，然后通过start()方法真正的去产生一个新的线程。
l解释器中来执行代码的叫做主线程。
l通过start()方法创建出来的叫做子线程。
l主线程会等待子线程全部结束之后才会结束。
l当调用Thread的时候，不会创建线程，当调用Thread创建出来的实例对象的start()方法的时候才会创建线程以及让这个线程开始运行。
查看当前线程：
利用threading里面的enumerate()函数就能返回一个列表，当前的线程作为单个元素存放在列表之中。
以上就是实现的全部内容了哦~大家在做项目时候，可以直接调用呢~如果还想知道更多的python知识，可以到云海天教程网进行查询。

指针作为参数的实际意义中，最重要定的是可以实现多个“返回值”
通过指针作为函数的传出参数可以实现函数的多值返回
例如
求阶乘的例子：
#include<stdio.h>
int Factorial(int input1)     //计算传入参数input的阶乘

{

        int result = 1;

        int j;

        if(input1 < 0)

        {

              printf("错误输入/n");

              return -1;

        }

       if(0 == input1)

        return result; 

        else

            for(j = 1;j <= input1;j++)

           {

                   result = result * j;

           }

         return result;

}
int FactorialSum(int input2)       //计算0!+1!+2!+...n!

{

           int i;

           int sum = 0;

           if(input2 < 0)

           return -1;

           else

            for(i = 0; i <= input2;i++)

           {

                 sum += Factorial(i);

          }

        return sum;

}
int Factorial2(int input3,int *sum) //使用传出参数，实现多值返回

{

           int result;

           int j;

           *sum = 0;

            result = Factorial(input3);

           for(j = 0;j <= input3;j++)

           {

                *sum += Factorial(j);

           }

      return result;

}
int main()

{

         int input;                //要输入的数据

         int result;      //单个数阶乘的结果

         int sum;                  //从0!到n!的和的结果
         printf("Please input the number: ");

         scanf("%d",&input);

         result = Factorial(input);

         printf("The Factorial of %d is %d/n",input,result);

         sum = FactorialSum(input);

         printf("The Facorial Sum from 0 to %d is: %d/n",input,sum);

         result = Factorial2(input,&sum);

         printf("The Facorial Sum from 0 to %d is: %d/n",input,sum);
         getchar();

         getchar();

         return 0;

}