在古老的C和c++中，内联就像寄存器:给编译器一个关于可能的优化的建议(只不过是一个建议)。

在现代c++中，内联告诉链接器，如果在不同的翻译单元中发现了多个定义(不是声明)，那么它们都是相同的，链接器可以自由地保留其中一个，并丢弃所有其他的定义。

如果一个函数(无论多么复杂或“线性”)定义在头文件中，内联是强制的，以允许多个源包含它而不会被链接器产生“多个定义”错误。

默认情况下，类内部定义的成员函数是“内联”的，模板函数也是如此(与全局函数相反)。

//fileA.h
inline void afunc()
{ std::cout << "this is afunc" << std::endl; }

//file1.cpp
#include "fileA.h"
void acall()
{ afunc(); }

//main.cpp
#include "fileA.h"
void acall();

int main()
{ 
   afunc(); 
   acall();
}

//output
this is afunc
this is afunc

注意fileA.h包含在两个.cpp文件中，导致两个afunc()实例。 链接器将丢弃其中一个。 如果没有指定inline，链接器将报错。

Generally speaking, these days with any modern compiler worrying about inlining anything is pretty much a waste of time. The compiler should actually optimize all of these considerations for you through its own analysis of the code and your specification of the optimization flags passed to the compiler. If you care about speed, tell the compiler to optimize for speed. If you care about space, tell the compiler to optimize for space. As another answer alluded to, a decent compiler will even inline automatically if it really makes sense.

另外，正如其他人所说，使用内联并不能保证任何东西都是内联的。如果你想要保证它，你必须定义一个宏而不是一个内联函数来实现它。

何时内联和/或定义宏强制包含?-只有当你对关键代码段的速度有了证明和必要的提高，并且知道这对应用程序的整体性能有影响时。

内联函数更快，因为你不需要将参数和返回地址等东西推入或弹出堆栈;但是，它确实会使二进制文件略大一些。

有显著的区别吗?对大多数人来说，在现代硬件上还不够明显。但它可以产生影响，这对一些人来说已经足够了。

将某些东西标记为内联并不能保证它将是内联的。这只是给编译器的一个建议。有时候是不可能的比如你有一个虚函数，或者涉及到递归。有时候编译器会选择不使用它。

我可以看到这样的情况会产生明显的不同:

inline int aplusb_pow2(int a, int b) {
  return (a + b)*(a + b) ;
}

for(int a = 0; a < 900000; ++a)
    for(int b = 0; b < 900000; ++b)
        aplusb_pow2(a, b);

这并不完全是关于性能。c++和C都用于嵌入式编程，位于硬件之上。例如，如果您要编写中断处理程序，则需要确保代码可以立即执行，而不会交换额外的寄存器和/或内存页。这就是内联派上用场的时候。好的编译器在需要速度时自己做一些“内联”，但“内联”迫使它们这样做。

内联允许您在头文件中放置函数定义，并在多个源文件中#包含该头文件，而不违反一个定义规则。

Why not make all functions inline by default? Because it's an engineering trade off. There are at least two types of "optimization": speeding up the program and reducing the size (memory footprint) of the program. Inlining generally speeds things up. It gets rid of the function call overhead, avoiding pushing then pulling parameters from the stack. However, it also makes the memory footprint of the program bigger, because every function call must now be replaced with the full code of the function. To make things even more complicated, remember that the CPU stores frequently used chunks of memory in a cache on the CPU for ultra-rapid access. If you make the program's memory image big enough, your program won't be able to use the cache efficiently, and in the worst case inlining could actually slow your program down. To some extent the compiler can calculate what the trade offs are, and may be able to make better decisions than you can, just looking at the source code.