So, my question is simple:
Is there any point in specifying a defaulted class constructor as noexcept
or constexpr
(or any other thing you could thing of)?
struct foo
{
foo() = default;
// vs
constexpr foo() noexcept = default;
// same thing would apply for copy/move ctors and assignment operators
};
Would the two behave the same way?
Does it depend on whether the class is POD? For example with the above example both would behave the same way, while if for example I had a private member std::vector<int> v = { 1, 2, 3, 4 };
which uses in-class assignment, foo() = default;
would by default not be noexcept
and not constexpr
.
By writing foo() = default;
does the compiler just pick the best version: noexcept
if possible and constexpr
if possible, etc?
2 An explicitly-defaulted function that is not defined as deleted may be declared
constexpr
only if it would have been implicitly declared asconstexpr
. If a function is explicitly defaulted on its first declaration,
- it is implicitly considered to be
constexpr
if the implicit declaration would be, and,- it has the same exception specification as if it had been implicitly declared ([except.spec]).
3 If a function that is explicitly defaulted is declared with an exception-specification that is not compatible ([except.spec]) with the exception specification of the implicit declaration, then
if the function is explicitly defaulted on its first declaration, it is defined as deleted;
otherwise, the program is ill-formed.
In other words, foo() = default;
, which is necessarily the first declaration of foo
's default constructor, will be " constexpr
if possible" and " noexcept
if possible". Explicitly writing constexpr
and noexcept
is still useful; it means "yell at me if it can't be constexpr
/ noexcept
".
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.