C++ 这两种定义方法之间有区别吗？ 备选案文1： 备选案文2：

注意，在选项2中，该方法也在标题中实现（标记为

内联
，以防止多重定义）。
正如您所介绍的，没有区别。然而，第二种形式有时用于利用可能跟随
类a
的声明

例如：

class A
{
  void foo();
};
class B : A { };
inline void A::foo() {
   B b;
}

在第一种形式中，这样使用
B
是不可能的。
这两种定义之间没有重大区别

在选项1中，该方法称为内联函数，不允许循环和更多行代码。因为执行速度快

在选项2中，即所谓的外部实体定义中，我们可以写任意数量的行

我认为内联意味着不阻止多重定义。这意味着只需编写少量代码而不需要循环等。
类定义中定义的方法是隐式的
内联的
，因此在功能上没有区别

Rob在一个差异上提供了一个很好的理由。这是另一个，依我看

假设你有：

class DBConnection
{
public:
   DBConnection(const Config& config)
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   void reconnect()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   void checkIntegrity()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   void runQuery()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   void dropTables()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   void disconnected(Callback callback)
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   void selectTables()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   Results getResults()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
        //YES, I copy-pasted these
   }
   //MANY MORE
}

告诉我，有没有办法在数据库断开连接时得到通知

现在，请使用以下命令重试：

class DBConnection
{
public:
   DBConnection(const Config& config);
   void reconnect();
   void checkIntegrity();
   void runQuery();
   void dropTables();
   void disconnected(Callback callback);
   void selectTables();
   Results getResults();
   //MANY MORE
};

inline DBConnection::DBConnection(const Config& config)
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   inline void DBConnection::reconnect()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   inline void DBConnection::checkIntegrity()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   inline void DBConnection::runQuery()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   inline void DBConnection::dropTables()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   inline void DBConnection::disconnected(Callback callback)
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   inline void DBConnection::selectTables()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
   }
   inline Results DBConnection::getResults()
   {
        //some
        //really
        //complicated
        //logic
        //and
        //checks
        //and
        //stuff
        //I dunno
        //not
        //a
        //db
        //guy
        //possibly
        //exceptions
        //thrown?
        //YES, I copy-pasted these
   }

更简单，对吧？
不，没有什么大区别。这两个函数都提示编译器方法foo（）可以/应该内联

KerrekSB正确地指出，它需要更多的代码，但当然也有好处：它提供了一个选项，可以将“接口”与“实现”分开，即使使用内联方法也是如此

例如，您可以在头文件的顶部显示类接口，并将.h文件的其余部分清楚地标记为“内联实现”。或者，您可以在内联实现中包含第二个头文件

//A.h
class A
{
    void foo();
};
// "import" the inline implementations
#include "A.ipp"

然后有一个.ipp，如下所示：

//A.ipp
inline void A::foo()
{
}

注意：由于“第三，非惯用的C++文件类型”，它会引起一些同事的混淆：H。“用于内联实现的源文件和.ipp。
它将具有相同的效果，是的。编译器实际上会将选项1视为选项2，因为这会影响类中稍后声明的名称的可见性。区别在于选项2占用更多的源代码行。这非常完整。@ixe013:该答案涉及是否使函数
内联
。在上面的两个选项中，函数都被标记为
inline
（类定义中定义的函数是隐式的
inline
），尽管它们在含义和正确性方面是等价的，但Marshall Cline在风格方面推荐选项2，我倾向于同意这是不允许循环的——我记得旧的borland编译器有这个限制——但今天情况并非如此。关于选项1的段落毫无意义。您可以在这两个地方编写完全相同的代码，编译器将同等对待它们。
//A.h
class A
{
    void foo();
};
// "import" the inline implementations
#include "A.ipp"

//A.ipp
inline void A::foo()
{
}