标签: noexcept

假设我有一个标记为的函数,noexcept但里面有一行代码可以抛出.那行代码将在try块中,异常将被捕获.这会导致什么吗？

void MyFunc() noexcept
{
    try {
        throw std::exception("...");
    } catch (const std::exception & e) {
        // I'll deal with it here...
    }
}

我正在使用GCC 5.2和clang 3.6进行测试,两者都在C++ 14模式下,并且它们提供相同的输出.

对于以下代码

#include <iostream>
#include <type_traits>

struct S {
  // S& operator= (S&&) noexcept { return *this; }
};


int main() {
  std::cout << std::is_nothrow_move_constructible<S>::value
            << std::is_nothrow_move_assignable<S>::value;  
}

11得到的结果.但是如果取消注释移动赋值运算符,则输出变为01.如何noexcept对移动赋值运算符的显式规范可能会影响移动构造函数的规范？

我是 C++ 初学者，正在学习一些 C++11 功能。我注意到的一件事是，在 Visual C++ stdlib 的某些部分中，作者使用了宏_NOEXCEPT而不是noexcept关键字。将鼠标悬停在宏上显示#define _NOEXCEPT noexcept，所以我有点困惑它的意义是什么。两者之间有什么区别，我应该选择其中一个而不是另一个？

编辑：我刚刚在 GitHub 上搜索了它，看起来clang也使用了它，所以它不是 Visual C++ 特定的宏。

是否允许标准书写decltype(::new (nullptr) T(std::declval< Args >()...))或noexcept(::new (nullptr) T(std::declval< Args >()...))？特别感兴趣的new是nullptr正确性.考虑以下代码:

#include <type_traits>
#include <utility>

struct S { S(int) { ; } ~S() = delete; };

struct A
{
    template< typename T,
              bool is_noexcept = noexcept(::new (nullptr) S(std::declval< T >())) >
    A(T && x) noexcept(is_noexcept)
        : s(new S(std::forward< T >(x)))
    { ; }

    S * s;
};

static_assert(std::is_constructible< A, int >{});
static_assert(!std::is_constructible< A, void * >{});

Disabler typename = decltype(S(std::declval< T >()))需要存在析构函数,但不需要放置new …

标准库定义了数组的交换,std::pair如下所示:

template <class T, size_t N>
void swap(T (&a)[N],
          T (&b)[N]) noexcept(noexcept(swap(*a, *b)));

template <class T1, class T2>
struct pair {
    …
    void swap(pair& p) noexcept(noexcept(swap(first,  p.first)) &&
                                noexcept(swap(second, p.second)));
    …
};

有效的现代C++第14项说:

[...]它们是否noexcept取决于noexcept条款中的表达方式noexcept.
给定两个阵列Widget,例如,交换它们是noexcept仅当在阵列中交换单独的元件是noexcept,即,如果用于交换Widget是noexcept.
即,反过来,确定其他互换,如一个用于数组的数组是否Widget是noexcept.
类似地,交换std::pair包含Widgets的两个对象noexcept是否取决于Widgets的交换是否为noexcept.

但是根据这个解释,我无法理解为什么有必要将呼叫嵌套为noexcept(noexcept(swap(*a, *b))).

如果目标是"交换两个数组应该noexcept像交换元素一样",为什么还noexcept(swap(*a, *b))不够？

这些不同的重载是 …

这是一个两部分的问题，第一部分是关于完全用 C++ 编写的东西，第二部分是关于用 C 编写但从 C++ 调用的函数之间的交互。

第1部分

让不同的翻译单元noexcept在同一函数的声明中看到不同的说明符是 ODR 还是其他违规行为？具体来说，如果一个单位看到：

void foo();

而另一个人看到：

void foo() noexcept;

这是 ODR 还是其他违规行为？您可能会假设该函数实际上永远不会抛出（即，它实际上可以被声明noexcept）。

第2部分

如果所有 C++ 代码都将声明视为extern "C" void foo() noexcept;，但该函数实际上是在 C 中定义（实现）的，其中声明（显然）不包含noexcept?

基本上按照标准：

继承构造函数 (12.9) 和隐式声明的特殊成员函数（第 12 条）具有异常规范。如果f是继承构造函数或隐式声明的默认构造函数、复制构造函数、移动构造函数、析构函数、复制赋值运算符或移动赋值运算符，则当且仅当异常规范允许时，其隐式异常规范指定类型 ID的隐式定义 直接调用的函数；如果它直接调用的任何函数允许所有异常，并且具有异常规范，则允许所有异常TTfff noexcept(true) 如果它直接调用的每个函数都不允许例外。

template<typename _Tp>
class Foo
{
public:
    Foo() = default;
    explicit Foo(const std::string& s, const std::function<bool(_Tp&)>& f) : stringField(s), funcField(f) {}

private:
    const std::string stringField;
    std::function<bool(_Tp&)> funcField;
};

int main()
{
    std::cout << "std::string: " << std::is_nothrow_move_constructible_v<std::string> << std::endl;
    std::cout << "std::function: " << std::is_nothrow_move_constructible_v<std::function<bool(std::string&)>> << std::endl;
    std::cout …