RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.github.io/LWG/issue2754 below:

The in_place constructors and emplace functions added by P0032R3 don't require CopyConstructible

This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of Resolved status.

2754. The in_place constructors and emplace functions added by P0032R3 don't require CopyConstructible

Section: 22.7.4.2 [any.cons], 22.7.4.3 [any.assign], 22.7.4.4 [any.modifiers] Status: Resolved Submitter: Ville Voutilainen Opened: 2016-07-05 Last modified: 2020-09-06

Priority: 1

View all other issues in [any.cons].

View all issues with Resolved status.

Discussion:

The in_place constructors and emplace functions added by P0032R3 don't require CopyConstructible.

They must. Otherwise copying an any that's made to hold a non-CopyConstructible type must fail with a run-time error. Since that's crazy, we want to prevent storing non-CopyConstructible types in an any. Previously, the requirement for CopyConstructible was just on the converting constructor template and the converting assignment operator template on any. Now that we are adding two in_place constructor overloads and two emplace overloads, it seems reasonable to require CopyConstructible in some more general location, in order to avoid repeating that requirement all over the place.

[2016-07 — Chicago]

Monday: P1

Tuesday: Ville/Billy/Billy provide wording

[2016-08-02: Daniel comments]

The P/R wording of this issue brought to my intention that the recently added emplace functions of std::any introduced a breakage of a previous class invariant that only a decayed type could be stored as object into an any, this prevented storing arrays, references, functions, and cv-qualified types. The new constraints added my Ville do prevent some of these types (e.g. neither arrays nor functions meet the CopyConstructible requirements), but we need to cope with cv-qualified types and reference types.

[2016-08-02: Agustín K-ballo Bergé comments]

Presumably the constructors any(in_place_type_t<T>, ...) would need to be modified in the same way the emplace overloads were.

[2016-08-02: Ville adjusts the P/R to cope with the problems pointed out by Daniel's and Agustín's comments]

Ville notes that 2746⁽ⁱ⁾, 2754⁽ⁱ⁾ and 2756⁽ⁱ⁾ all go together.

Previous resolution [SUPERSEDED]:

This wording is relative to N4606.

Drafting note: this P/R doesn't turn the Requires-clauses into Remarks-clauses. We might want to do that separately, because SFINAEing the constructors allows users to query for is_constructible and get the right answer. Failing to mandate the SFINAE will lead to non-portable answers for is_constructible. Currently, libstdc++ SFINAEs. That should be done as a separate issue, as this issue is an urgent bug-fix but the mandated SFINAE is not.
Change 22.7.4 [any.class], class any synopsis, as indicated:
class any {
public:
 […]
 template <class TValueType, class... Args>
 explicit any(in_place_type_t<TValueType>, Args&&...);
 template <class TValueType, class U, class... Args>
 explicit any(in_place_type_t<TValueType>, initializer_list, Args&&...);
 
 […]
 template <class TValueType, class... Args>
 void emplace(Args&& ...);
 template <class TValueType, class U, class... Args>
 void emplace(initializer_list, Args&&...);
 […]
};
Change 22.7.4.2 [any.cons] as indicated:
template<class ValueType>
 any(ValueType&& value);
-6- Let T be equal to decay_t<ValueType>.
-7- Requires: T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed. […] -9- Remarks: This constructor shall not participate in overload resolution if unlessdecay_t<ValueType> is not the same type as any and is_copy_constructible_v<T> is true.
template <class TValueType, class... Args>
 explicit any(in_place_type_t<TValueType>, Args&&... args);
-?- Let T be equal to remove_cv_t<ValueType>.
-11- Requires: T shall satisfy the CopyConstructible requirements is_constructible_v<T, Args...> is true. […] -?- Remarks: This constructor shall not participate in overload resolution unless is_reference_v<T> is false, is_array_v<T> is false, is_function_v<T> is false, is_copy_constructible_v<T> is true and is_constructible_v<T, Args...> is true.
template <class TValueType, class U, class... Args>
 explicit any(in_place_type_t<TValueType>, initializer_list il, Args&&... args);
-?- Let T be equal to remove_cv_t<ValueType>.
-15- Requires: T shall satisfy the CopyConstructible requirements is_constructible_v<T, initializer_list&, Args...> is true. […] -19- Remarks: The function shall not participate in overload resolution unless is_reference_v<T> is false, is_array_v<T> is false, is_function_v<T> is false, is_copy_constructible_v<T> is true andis_constructible_v<T, initializer_list&, Args...> is true.
Change 22.7.4.3 [any.assign] as indicated:
template<class ValueType>
 any& operator=(ValueType&& rhs);
-7- Let T be equal to decay_t<ValueType>.
-8- Requires: T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed. […] -11- Remarks: This operator shall not participate in overload resolution if unlessdecay_t<ValueType> is not the same type as any and is_copy_constructible_v<T> is true.
Change 22.7.4.4 [any.modifiers] as indicated:
template <class TValueType, class... Args>
 void emplace(Args&&... args);
-?- Let T be equal to remove_cv_t<ValueType>.
-1- Requires: T shall satisfy the CopyConstructible requirements is_constructible_v<T, Args...> is true. […] -5- Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and any previously contained object has been destroyed. This function shall not participate in overload resolution unless is_reference_v<T> is false, is_array_v<T> is false, is_function_v<T> is false, is_copy_constructible_v<T> is true and is_constructible_v<T, Args...> is true.
template <class TValueType, class U, class... Args>
 void emplace(initializer_list il, Args&&... args);
-?- Let T be equal to remove_cv_t<ValueType>.
-?- Requires: T shall satisfy the CopyConstructible requirements. -6- Effects: […] […] -9- Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and any previously contained object has been destroyed. The function shall not participate in overload resolution unless is_reference_v<T> is false, is_array_v<T> is false, is_function_v<T> is false, is_copy_constructible_v<T> is true andis_constructible_v<T, initializer_list&, Args...> is true.

[2016-08-03: Ville comments and revises his proposed wording]

After discussing the latest P/R, here's an update. What this update does is that:

It strikes the Requires-clauses and does not add CopyConstructible to the Requires-clauses.
Rationale: any doesn't care whether the type it holds satisfies the semantic requirements of the CopyConstructible concept. The syntactic requirements are now SFINAE constraints in Requires-clauses.
It reverts back towards decay_t rather than remove_cv_t, and does not add the suggested SFINAE constraints for is_reference/is_array/is_function.
Rationale:
1. any decays by design. It's to some extent inconsistent to not protect against decay in the ValueType constructor/assignment operator, but to protect against decay in the in_place_t constructors and emplace functions
2. I think it's saner to just decay than to potentially run into situations where I need to remove_reference inside in_place_t.

Based on that, this P/R should supersede the previous one. We want to look at this new P/R in LWG and potentially send it to LEWG for verification. Personally, I think this P/R is the more conservative one, doesn't add significant new functionality, and is consistent, and is thus not really Library-Evolutionary.

Previous resolution [SUPERSEDED]:

This wording is relative to N4606.
Change 22.7.4 [any.class], class any synopsis, as indicated:
class any {
public:
 […]
 template <class TValueType, class... Args>
 explicit any(in_place_type_t<TValueType>, Args&&...);
 template <class TValueType, class U, class... Args>
 explicit any(in_place_type_t<TValueType>, initializer_list, Args&&...);
 
 […]
 template <class TValueType, class... Args>
 void emplace(Args&& ...);
 template <class TValueType, class U, class... Args>
 void emplace(initializer_list, Args&&...);
 […]
};
Change 22.7.4.2 [any.cons] as indicated:
template<class ValueType>
 any(ValueType&& value);
-6- Let T be equal to decay_t<ValueType>.
-7- Requires: T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed. […] -9- Remarks: This constructor shall not participate in overload resolution if unlessdecay_t<ValueType> is not the same type as any and is_copy_constructible_v<T> is true.
template <class TValueType, class... Args>
 explicit any(in_place_type_t<TValueType>, Args&&... args);
-?- Let T be equal to decay_t<ValueType>.
-11- Requires: is_constructible_v<T, Args...> is true. […] -?- Remarks: This constructor shall not participate in overload resolution unless is_copy_constructible_v<T> is true and is_constructible_v<T, Args...> is true.
template <class TValueType, class U, class... Args>
 explicit any(in_place_type_t<TValueType>, initializer_list il, Args&&... args);
-?- Let T be equal to decay_t<ValueType>.
-15- Requires: is_constructible_v<T, initializer_list&, Args...> is true. […] -19- Remarks: The function shall not participate in overload resolution unless is_copy_constructible_v<T> is true andis_constructible_v<T, initializer_list&, Args...> is true.
Change 22.7.4.3 [any.assign] as indicated:
template<class ValueType>
 any& operator=(ValueType&& rhs);
-7- Let T be equal to decay_t<ValueType>.
-8- Requires: T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed. […] -11- Remarks: This operator shall not participate in overload resolution if unlessdecay_t<ValueType> is not the same type as any and is_copy_constructible_v<T> is true.
Change 22.7.4.4 [any.modifiers] as indicated:
template <class TValueType, class... Args>
 void emplace(Args&&... args);
-?- Let T be equal to decay_t<ValueType>.
-1- Requires: is_constructible_v<T, Args...> is true. […] -5- Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and any previously contained object has been destroyed. This function shall not participate in overload resolution unless is_copy_constructible_v<T> is true and is_constructible_v<T, Args...> is true.
template <class TValueType, class U, class... Args>
 void emplace(initializer_list il, Args&&... args);
-?- Let T be equal to decay_t<ValueType>.
-6- Effects: […] […] -9- Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and any previously contained object has been destroyed. The function shall not participate in overload resolution unless is_copy_constructible_v<T> is true andis_constructible_v<T, initializer_list&, Args...> is true.

[2016-08-03: Ville comments and revises his proposed wording]

This P/R brings back the CopyConstructible parts of the relevant Requires-clauses but removes the other parts of the Requires-clauses.

[2016-08 - Chicago]

Thurs PM: Moved to Tentatively Ready

[2016-11 - Issaquah]

Approved in plenary.

After plenary, there was concern about applying both this and 2744⁽ⁱ⁾, so it was moved back to "Open". Then, when the concerns were resolved, moved to "Resolved".

Proposed resolution:

This wording is relative to N4606.

Change 22.7.4 [any.class], class any synopsis, as indicated:

class any {
public:
  […]
  template <class TValueType, class... Args>
    explicit any(in_place_type_t<TValueType>, Args&&...);
  template <class TValueType, class U, class... Args>
    explicit any(in_place_type_t<TValueType>, initializer_list<U>, Args&&...);
    
  […]
  template <class TValueType, class... Args>
    void emplace(Args&& ...);
  template <class TValueType, class U, class... Args>
    void emplace(initializer_list<U>, Args&&...);
  […]
};

Change 22.7.4.2 [any.cons] as indicated:
```
template<class ValueType>
 any(ValueType&& value);
```
-6- Let T be decay_t<ValueType>.
-7- Requires: T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed. […] -9- Remarks: This constructor shall not participate in overload resolution if unless T decay_t<ValueType> is not the same type as any and is_copy_constructible_v<T> is true.
```
template <class TValueType, class... Args>
 explicit any(in_place_type_t<TValueType>, Args&&... args);
```
-?- Let T be decay_t<ValueType>.
-11- Requires: T shall satisfy the CopyConstructible requirements is_constructible_v<T, Args...> is true. […] -?- Remarks: This constructor shall not participate in overload resolution unless is_copy_constructible_v<T> is true and is_constructible_v<T, Args...> is true.
```
template <class TValueType, class U, class... Args>
 explicit any(in_place_type_t<TValueType>, initializer_list il, Args&&... args);
```
-?- Let T be decay_t<ValueType>.
-15- Requires: T shall satisfy the CopyConstructible requirements is_constructible_v<T, initializer_list&, Args...> is true. […] -19- Remarks: The function shall not participate in overload resolution unless is_copy_constructible_v<T> is true andis_constructible_v<T, initializer_list&, Args...> is true.
Change 22.7.4.3 [any.assign] as indicated:
```
template<class ValueType>
 any& operator=(ValueType&& rhs);
```
-7- Let T be decay_t<ValueType>.
-8- Requires: T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed. […] -11- Remarks: This operator shall not participate in overload resolution if unless T decay_t<ValueType> is not the same type as any and is_copy_constructible_v<T> is true.
Change 22.7.4.4 [any.modifiers] as indicated:
```
template <class TValueType, class... Args>
 void emplace(Args&&... args);
```
-?- Let T be decay_t<ValueType>.
-1- Requires: T shall satisfy the CopyConstructible requirements is_constructible_v<T, Args...> is true. […] -5- Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and any previously contained object has been destroyed. This function shall not participate in overload resolution unless is_copy_constructible_v<T> is true and is_constructible_v<T, Args...> is true.
```
template <class TValueType, class U, class... Args>
 void emplace(initializer_list il, Args&&... args);
```
-?- Let T be decay_t<ValueType>.
-?- Requires: T shall satisfy the CopyConstructible requirements. -6- Effects: […] […] -9- Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and any previously contained object has been destroyed. The function shall not participate in overload resolution unless is_copy_constructible_v<T> is true andis_constructible_v<T, initializer_list&, Args...> is true.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4