实际上，几乎从来没有。你所做的只是建议编译器将给定的函数内联(例如，替换对该函数的所有调用/w它的函数体)。当然，这不能保证:编译器可能会忽略该指令。

编译器通常会很好地检测和优化这样的事情。

一个用例可能发生在继承上。例如，如果以下所有情况都为真:

你有某个类的基类 基类需要是抽象的 基类除了析构函数之外没有纯虚方法 您不希望为基类创建CPP文件，因为这是徒劳的

然后你必须定义析构函数;否则，你会有一些未定义的引用链接错误。此外，你不仅要定义，还要用inline关键字定义析构函数;否则，您将有多个定义链接错误。

这可能发生在一些只包含静态方法或编写基异常类的辅助类上。

让我们举个例子:

Base.h:

class Base {
public:
    Base(SomeElementType someElement) noexcept : _someElement(std::move(someElement)) {}

    virtual ~Base() = 0;

protected:
    SomeElementType _someElement;
}

inline Base::~Base() = default;

Derived1.h:

#include "Base.h"

class Derived1 : public Base {
public:
    Derived1(SomeElementType someElement) noexcept : Base(std::move(someElement)) {}

    void DoSomething1() const;
}

Derived1.cpp:

#include "Derived1.h"

void Derived1::DoSomething1() const {
    // use _someElement 
}

Derived2.h:

#include "Base.h"

class Derived2 : public Base {
public:
    Derived2(SomeElementType someElement) noexcept : Base(std::move(someElement)) {}

    void DoSomething2() const;
}

Derived2.cpp:

#include "Derived2.h"

void Derived2::DoSomething2() const {
    // use _someElement 
}

通常，抽象类有一些纯虚方法，而不是构造函数或析构函数。因此，你不必分离基类的虚析构函数的声明和定义，你可以只写virtual ~ base () = default;关于类声明。然而，在我们的案例中，情况并非如此。

据我所知，MSVC允许你在类声明上写这样的东西:virtual ~Base() = 0{}。所以你不需要用内联关键字分离声明和定义。但它将只与MSVC编译器工作。

现实世界的例子:

BaseException.h:

#pragma once

#include <string>

class BaseException : public std::exception {
public:
    BaseException(std::string message) noexcept : message(std::move(message)) {}
    virtual char const* what() const noexcept { return message.c_str(); }

    virtual ~BaseException() = 0;

private:
    std::string message;
};

inline BaseException::~BaseException() = default;

SomeException.h:

#pragma once

#include "BaseException.h"

class SomeException : public BaseException {
public:
    SomeException(std::string message) noexcept : BaseException(std::move(message)) {}
};

SomeOtherException.h:

#pragma once

#include "BaseException.h"

class SomeOtherException : public BaseException {
public:
    SomeOtherException(std::string message) noexcept : BaseException(std::move(message)) {}
};

main.cpp:

#include <SomeException.h>
#include <SomeOtherException.h>

#include <iostream>

using namespace std;

static int DoSomething(int argc) {
    try {
        switch (argc) {
        case 0:
            throw SomeException("some");
        case 1:
            throw SomeOtherException("some other");
        default:
            return 0;
        }
    }
    catch (const exception& ex) {
        cout << ex.what() << endl;
        return 1;
    }
}

int main(int argc, char**) {
    return DoSomething(argc);
}

实际上，几乎从来没有。你所做的只是建议编译器将给定的函数内联(例如，替换对该函数的所有调用/w它的函数体)。当然，这不能保证:编译器可能会忽略该指令。

编译器通常会很好地检测和优化这样的事情。

在开发和调试代码时，不要使用内联。这会使调试复杂化。

添加它们的主要原因是为了帮助优化生成的代码。通常，这是以增加的代码空间换取速度，但有时内联可以同时节省代码空间和执行时间。

在算法完成之前将这种思想扩展到性能优化是不成熟的优化。

1)如今，几乎从来没有。如果内联一个函数是个好主意，编译器会在没有你帮助的情况下完成它。

2)。看到# 1。

(经过编辑，反映出你把问题分成了两个问题……)

你要把它放在最开始，在返回类型之前。但是大多数编译器忽略了它。如果它是定义的，并且它的代码块较小，大多数编译器都认为它是内联的。