C++ 我应该什么时候写关键字'；内联'；对于函数/方法？ >

在看到一些答案后，一些相关问题：

<> L> >P>何时应该在C++（
）中为函数/方法编写关键字“内联”？
• 编译器什么时候不知道什么时候使函数/方法“内联”

• 当为函数/方法写入“内联”时，如果应用程序是多线程的，这是否重要

如今，几乎从来没有。如果内联函数是个好主意，编译器将在没有您帮助的情况下完成它
2） 总是。见#1

---

（编辑以反映您将问题分成两个问题…
事实上，几乎从来没有。您所做的只是建议编译器将给定函数内联（例如，替换对该函数的所有调用/w函数体）。当然，没有任何保证：编译器可能会忽略该指令

---

编译器通常会很好地检测并优化这样的事情
您希望将其放在返回类型之前的最开始处。但大多数编译器忽略了它。如果它被定义，并且它有更小的代码块，那么大多数编译器都认为它是内联的。p> 在开发和调试代码时，不要使用

inline

。它使调试复杂化
添加它们的主要原因是帮助优化生成的代码。通常，这会以增加的代码空间换取速度，但有时

inline

会节省代码空间和执行时间

---

在算法完成之前扩展这种关于性能优化的思想是非常困难的。
在进行模板专门化时，仍然需要显式地内联函数（如果专门化在.h文件中）
当应该内联时：
1.为了避免调用函数时发生的开销，例如参数传递、控制传递、控制返回等
2.函数应该很小，经常调用，内联是非常有利的，因为按照80-20规则，尽量使那些对程序性能有重大影响的函数内联

---

正如我们所知，内联只是对编译器的一个请求，类似于注册，它将以对象代码大小为代价。
噢，伙计，我最讨厌的一个

inline

更像是

static

或

extern

，而不是告诉编译器内联函数的指令<代码>外部，

静态

，

内联

是链接指令，链接器几乎只使用链接指令，而不是编译器

---

据说

inline

提示编译器您认为函数应该内联。1998年可能是这样，但十年后编译器不需要这样的提示。更不用说人类在优化代码时通常是错误的，所以大多数编译器完全忽略了“提示”

• 静态

  -变量/函数名不能在其他转换单元中使用。链接器需要确保它不会意外地使用来自另一个翻译单元的静态定义变量/函数

• extern

  -在此翻译单元中使用此变量/函数名，但如果未定义，请不要抱怨。链接器将对其进行排序，并确保尝试使用某个外部符号的所有代码都有其地址

• 内联

  -此函数将在多个翻译单元中定义，不用担心。链接器需要确保所有转换单元使用变量/函数的单个实例

注意：通常，声明模板

inline

是没有意义的，因为它们已经具有

inline

的链接语义。但是，需要使用模板的显式专门化和实例化

---

对您的问题的具体回答：
• <何时我应该为C++中的函数/方法编写关键字“内联”？< /p> 仅当您希望在标头中定义函数时。更确切地说，只有当函数的定义可以在多个翻译单元中显示时。在头文件中定义小函数（如在一行程序中）是一个好主意，因为它在优化代码时为编译器提供了更多的信息。它还增加了编译时间

• <何时我不应该为C++中的函数/方法编写关键字“内联”？< /p> 不要仅仅因为您认为如果编译器将代码内联，那么您的代码将运行得更快而添加内联代码

• 编译器什么时候不知道什么时候使函数/方法“内联”
  一般来说，编译器会比您做得更好。但是，如果没有函数定义，编译器就不能选择内联代码。在最大化优化的代码中，无论您是否要求，通常所有的

  private

  方法都是内联的
  为了防止GCC中的内联，可以使用

  \uuuu属性（noinline））

  ，在Visual Studio中，可以使用

  \uuu declspec（noinline）

• 当为函数/方法写入“内联”时，应用程序是否为多线程应用程序是否重要
  多线程不会以任何方式影响内联

---

默认情况下，gcc在编译时不内联任何函数 已启用优化。我不知道VisualStudio–灵巧的代码
我通过使用/FAcs编译并查看汇编代码，在Visual Studio 9（15.00.30729.01）中对此进行了检查： 编译器生成了对成员函数的调用，而未在调试模式下启用优化。即使函数被标记为\uu forceinline，也不会生成内联运行时代码。
• 编译器什么时候不知道什么时候使函数/方法“内联”
<

#include <iostream>

void bar();

inline int fun() {
  return 111;
}

int main() {
  std::cout << "inline111: fun() = " << fun() << ", &fun = " << (void*) &fun;
  bar();
}

#include <iostream>

inline int fun() {
  return 222;
}

void bar() {
  std::cout << "inline222: fun() = " << fun() << ", &fun = " << (void*) &fun;
}

g++ -std=c++11 inline111.cpp inline222.cpp

inline111: fun() = 111, &fun = 0x4029a0
inline222: fun() = 111, &fun = 0x4029a0

g++ -std=c++11 inline222.cpp inline111.cpp

inline111: fun() = 222, &fun = 0x402980
inline222: fun() = 222, &fun = 0x402980

g++ -std=c++11 -O2 inline222.cpp inline111.cpp

g++ -std=c++11 -O2 inline111.cpp inline222.cpp

inline111: fun() = 111, &fun = 0x402900
inline222: fun() = 222, &fun = 0x402900

#include <iostream>

using namespace std;

inline int Max(int x, int y) { return (x > y)? x : y; }

// Main function for the program
int main() {
   cout << "Max (100,1010): " << Max(100,1010) << endl;

   return 0;
}

#include <iostream>
extern inline int i[];
int i [5];
struct c {
  int function (){return 1;} // implicitly inline
  static inline int j = 3; // explicitly inline
  static int k; // without inline, a static member has to be defined out of line
  static int f (){return 1;} // but a static method does not // implicitly inline
};

extern inline int b;
int b=3;
int c::k = 3; // when a static member is defined out of line it cannot have a static
              // specifier and if it doesn't have an `inline` specifier in the
              // declaration or on the definition then it is not inline and always
              // emits a strong global symbol in the translation unit

int main() {
  c j;
  std::cout << i;
}

extern inline int i[];
extern int i[]; //allowed repetition of declaration with incomplete type, inherits inline property
extern int i[5]; //declaration now has complete type
extern int i[5]; //allowed redeclaration if it is the same complete type or has not yet been completed
extern int i[6]; //error, redeclaration with different complete type
int i[5]; //definition, must have complete type and same complete type as the declaration if there is a declaration with a complete type