This kind of function may not throw. Declare it 'noexcept'.

C++ Core Guidelines F.6: If your function may not throw, declare it noexcept

Some kinds of operations should never cause exceptions. Their implementations should be reliable and should handle possible errors conditions gracefully. They should never use exceptions to indicate failure. This rule flags cases where such operations aren't explicitly marked as noexcept, which means that they may throw exceptions and can't convey assumptions about their reliability.

• Special kinds of operations:

  • destructors;
  • default constructors;
  • move constructors and move assignment operators;
  • standard functions with move semantics: std::move and std::swap.

• Non-standard and outdated specifiers like throw() or declspec(nothrow) aren't equivalent to noexcept.

• Explicit specifiers noexcept(false) and noexcept(true) are respected appropriately.

• The warning may still appear for operations that are marked as constexpr. This check may change in future releases.

All functions except the destructor will warn because they're missing noexcept.

struct S
{
    S() {} // C26455, Default constructor may not throw. Declare it 'noexcept'
    ~S() {}

    S(S&& s) {/*impl*/} // C26439, This kind of function may not throw. Declare it 'noexcept' (f.6)
    S& operator=(S&& s) {/*impl*/} // C26439, This kind of function may not throw. Declare it 'noexcept' (f.6)

    S(const S& s) {/*impl*/} // C26440, This function can be declared 'noexcept'
    S& operator=(const S& s) {/*impl*/} // C26440, This function can be declared 'noexcept'
};

With noexcept decorating the same structure, all warnings are removed.

struct S
{
    S() noexcept {}
    ~S() {}

    S(S&& s) noexcept {/*impl*/}
    S& operator=(S&& s) noexcept {/*impl*/}

    S(const S& s) noexcept {/*impl*/}
    S& operator=(const S& s) noexcept {/*impl*/}
};