Are the copy constructor and copy assignment of std::runtime_error noexcept?
<p>All of GCC 4.8.4, 4.9.3, 5.3.0 pass the tests for <code>std::exception</code> (for any of -std=c++11/1y/14/1z/17 options, where available):</p>

<pre><code>static_assert(std::is_nothrow_copy_constructible&lt;std::exception&gt;::value, "test exception");
static_assert(std::is_nothrow_copy_assignable   &lt;std::exception&gt;::value, "test exception");
</code></pre>

<p>Which is fine, since <code>std::exception</code> has noexcept special members (C++14 18.8.1):</p>

<blockquote>
<pre><code>namespace std {
  class exception {
  public:
    exception() noexcept;
    exception(const exception&amp;) noexcept;
    exception&amp; operator=(const exception&amp;) noexcept;
    virtual ~exception();
    virtual const char* what() const noexcept;
  };
}
</code></pre>
</blockquote>

<p>Unfortunately, all of the compilers above fail on the following <code>static_assert</code>s:</p>

<pre><code>static_assert(std::is_nothrow_copy_constructible&lt;std::runtime_error&gt;::value, "test runtime_error");
static_assert(std::is_nothrow_copy_assignable   &lt;std::runtime_error&gt;::value, "test runtime_error");
</code></pre>

<p>The standard contains only the following about <code>std::runtime_error</code> in 19.2.6:</p>

<blockquote>
<pre><code>namespace std {
  class runtime_error : public exception {
  public:
    explicit runtime_error(const string&amp; what_arg);
    explicit runtime_error(const char* what_arg);
  };
}
</code></pre>
</blockquote>

<p>But nothing is said about the <code>noexcept</code>ness of the other (implicitly declared special) members nor the storage implementation requirements of <code>what_arg</code>.</p>

<p>The standard (C++14) says the following in 15.4/14:</p>

<blockquote>
  <p>An inheriting constructor (12.9) and an implicitly declared special
  member function (Clause 12) have an exception-specification. If f is
  an inheriting constructor or an implicitly declared default
  constructor, copy constructor, move constructor, destructor, copy
  assignment operator, or move assignment operator, its implicit
  exception-specification specifies the type-id T if and only if T is
  allowed by the exception-specification of a function directly invoked
  by f’s implicit definition; f allows all exceptions if any function it
  directly invokes allows all exceptions, and f has the
  exception-specification noexcept(true) if every function it directly
  invokes allows no exceptions.</p>
</blockquote>

<p>And the following in 18.8.1/2:</p>

<blockquote>
  <p>Each standard library class T that derives from class exception shall
  have a publicly accessible copy constructor and a publicly
  accessible copy assignment operator that do not exit with an
  exception.</p>
</blockquote>

<p>Since <code>std::runtime_error</code> does not expose the implementation of the <code>what_arg</code> storage, we do not know whether it's (special) members are noexcept or not, so the noexceptness of <code>std::runtime_error</code>'s copy constructor or copy assignment members are undecidable. Our only bet is 18.8.1 above.</p>

<p>Question 1/a) We consider <code>std::runtime_error</code>'s copy constructor or copy assignment to be noexcept (<a href="https://www.securecoding.cert.org/confluence/display/cplusplus/ERR60-CPP.+Exception+objects+must+be+nothrow+copy+constructible">1</a>, <a href="https://groups.google.com/a/isocpp.org/d/msg/std-discussion/NiPG1hmo4ik/DePB57IPmJwJ">2</a>). Is this true / state-of-the-art / best practice?</p>

<p>Question 1/b) Do not we need to explicitly state this in the standard? (Like in 18.8.2, Class <code>bad_exception</code>)</p>

<p>Question 1/c) Is it a bug in GCC that it fails the static_assert tests above?</p>

<p>Question 2) If the above deduction is wrong, could someone point me to the section(s) in the standard which state that std::runtime_error has noexcept copy constructor (and copy assignment)? (Or where it states that they are not.)</p>