C++ 我可以停止使用“吗？”；内联“；总共

因为它是否内联我的函数完全取决于编译器，我可以完全停止使用这个关键字吗（假设它将内联所有它能内联的东西）？

你可以停止使用

内联

作为优化技术

inline

基本上只在您不希望应用的情况下才有用。简而言之，您可以将函数标记为

inline

，并在一个头文件中直接提供它们的定义，然后由多个翻译单元导入，而链接器不会对此抱怨：

foo.hpp

inline int foo() { return 42; }

#include "foo.hpp" // <== THE LINKER WOULD COMPLAIN IF foo() WERE NOT inline,
                   //     because its definition is imported also in main.cpp
void bar()
{
    int x = foo();
}

#include "foo.hpp" // <== THE LINKER WOULD COMPLAIN IF foo() WERE NOT inline,
                   //     because its definition is imported also in foo.cpp
int main()
{
    std::cout << foo();
}

inline int foo() // Has the same body in main.cpp, no problem!
{
    return 42;
}

inline int foo() // Has the same body in foo.cpp, no problem!
{
    return 42;
}

int main()
{
    std::cout << foo();
}

inline int foo()
{
    return 42;  // <== WATCH OUT! Different body in main.cpp
}

inline int foo()
{
    return -42; // <== WATCH OUT! Different body in foo.cpp
}

int main()
{
    std::cout << foo();
}

foo.cpp

inline int foo() { return 42; }

#include "foo.hpp" // <== THE LINKER WOULD COMPLAIN IF foo() WERE NOT inline,
                   //     because its definition is imported also in main.cpp
void bar()
{
    int x = foo();
}

#include "foo.hpp" // <== THE LINKER WOULD COMPLAIN IF foo() WERE NOT inline,
                   //     because its definition is imported also in foo.cpp
int main()
{
    std::cout << foo();
}

inline int foo() // Has the same body in main.cpp, no problem!
{
    return 42;
}

inline int foo() // Has the same body in foo.cpp, no problem!
{
    return 42;
}

int main()
{
    std::cout << foo();
}

inline int foo()
{
    return 42;  // <== WATCH OUT! Different body in main.cpp
}

inline int foo()
{
    return -42; // <== WATCH OUT! Different body in foo.cpp
}

int main()
{
    std::cout << foo();
}

main.cpp

inline int foo() { return 42; }

#include "foo.hpp" // <== THE LINKER WOULD COMPLAIN IF foo() WERE NOT inline,
                   //     because its definition is imported also in main.cpp
void bar()
{
    int x = foo();
}

#include "foo.hpp" // <== THE LINKER WOULD COMPLAIN IF foo() WERE NOT inline,
                   //     because its definition is imported also in foo.cpp
int main()
{
    std::cout << foo();
}

inline int foo() // Has the same body in main.cpp, no problem!
{
    return 42;
}

inline int foo() // Has the same body in foo.cpp, no problem!
{
    return 42;
}

int main()
{
    std::cout << foo();
}

inline int foo()
{
    return 42;  // <== WATCH OUT! Different body in main.cpp
}

inline int foo()
{
    return -42; // <== WATCH OUT! Different body in foo.cpp
}

int main()
{
    std::cout << foo();
}

inline int foo（）//在foo.cpp中有相同的主体，没问题！
{
返回42；
}
int main（）
{
std:：cout取决于使用
inline
的目的

常见（mis）概念：

inline
只是一个建议，编译器可能会遵守，也可能不会遵守。一个好的编译器无论如何都会做需要做的事情

然而，事实是：

inline
通常向实现表明，调用点处函数体的内联替换优先于通常的函数调用机制。实现不需要在调用点处执行此内联替换；但是，即使忽略此
inline
替换ted，遵循
inline
的其他规则（特别是w.r.t）。

因此，如果您的使用目的是优化，那么答案是：

是的，您可以停止使用
内联
。大多数现代编译器都会很好地为您做到这一点

但是，如果使用
inline
的目的是允许您通过一个定义规则并在头文件中定义函数体，而不破坏ODR，那么答案是：

否，您需要将函数显式标记为
内联
才能绕过ODR。

注意：在类主体中定义的成员函数是隐式的
inline
，但这不适用于自由函数。
并且，即使您从未使用
inline
，也可以隐式使用它：
struct Foo{int x；Foo（）：x（0）{}；
在一个.cpp文件中，以及
struct Foo{double d；Foo（）：d（0）{}；
在另一个.cpp文件中，您刚刚隐式创建了两个名为
Foo:：Foo
的
inline
构造函数。@Yakk:那么您的程序有未定义的行为，除非
Foo
都在匿名命名空间中声明。@MatthieuM.yes，我在生产代码中看到过这种情况。基本上，我是说即使如果你不使用
inline
，你可能会被它咬到，所以你需要了解
inline
到底是什么，即使你不使用它。