C++23対応としてコンテナのアロケータ型の推論方法を見直し #1052

Author: faithandbrave

lang/cpp23.md

@@ -127,7 +127,7 @@ C++23とは、2023年中に改訂され、ISO/IEC 14882:2024で標準規格化
 
 ### コンテナ
 - [`std::stack`](/reference/stack/stack.md)と[`std::queue`](/reference/queue/queue.md)に、イテレータのペアをとるコンストラクタを追加
-- `auto v = std::vector(v, alloc);`のようなアロケータ引数をともなう場合のクラステンプレートのテンプレート引数推論が動作しなかったため、各コンテナクラスのコンストラクタにおけるアロケータパラメータの型を`const Allocator&`から`const` [`std::type_identity_t`](/reference/type_traits/type_identity.md)`<Allocator>&`に修正
+- `auto v = std::vector(v, alloc);`のようなアロケータ引数をともなう場合のクラステンプレートのテンプレート引数推論が動作しなかったため、各コンテナクラスのコンストラクタにおけるアロケータパラメータの型を`const Allocator&`から`const` [`std::type_identity_t`](/reference/type_traits/type_identity.md)`<Allocator>&`に修正し、コンテナアダプタの推論補助の制約を修正
 - N要素のメモリアロケート時にアロケータが実際にどれくらいのメモリを確保したかを得られるインタフェースとして、
     - [`std::allocator`](/reference/memory/allocator.md)クラスに、[`allocate_at_least()`](/reference/memory/allocator/allocate_at_least.md)メンバ関数を追加
     - [`std::allocator_traits`](/reference/memory/allocator_traits.md)クラスに、[`allocate_at_least()`](/reference/memory/allocator_traits/allocate_at_least.md)関数を追加

reference/deque/deque/op_constructor.md

@@ -26,8 +26,12 @@ deque(InputIterator first, InputIterator last,
 
 deque(const deque& x);                            // (6)
 deque(deque&& y);                                 // (7) C++11 から
-deque(const deque& x, const Allocator& a);        // (8) C++11 から
-deque(deque&& y, const Allocator& a);             // (9) C++11 から
+deque(const deque& x, const Allocator& a);                  // (8) C++11
+deque(const deque& x,
+      const type_identity_t<Allocator>& a);                 // (8) C++23
+
+deque(deque&& y, const Allocator& a);                       // (9) C++11
+deque(deque&& y, const type_identity_t<Allocator>& a);      // (9) C++23
 
 deque(initializer_list<T> il,
       const Allocator& a = Allocator());          // (10) C++11 から
@@ -36,6 +40,7 @@ template <container-compatible-range<T> R>
 deque(from_range_t, R&& rg,
       const Allocator& a = Allocator());          // (11) C++23 から
 ```
+* type_identity_t[link /reference/type_traits/type_identity.md]
 * initializer_list[link /reference/initializer_list/initializer_list.md]
 * from_range_t[link ../../ranges/from_range_t.md]
 
@@ -111,6 +116,9 @@ deque(from_range_t, R&& rg,
     * std::scoped_allocator_adaptor[link ../../scoped_allocator/scoped_allocator_adaptor.md]
     * emplace_back[link ../../list/list/emplace_back.md]
 
+- C++23 では、(8) と (9) のアロケータパラメータの型が `const Allocator&` から `const type_identity_t<Allocator>&` に変更された。
+	これは、クラステンプレートのテンプレート引数推論 (CTAD) の際に、コピー/ムーブ元の `deque` から推論される `Allocator` と、アロケータ引数から推論される型が異なる場合に推論が失敗する問題を修正するためである。[`type_identity_t`](/reference/type_traits/type_identity.md) で包むことで、アロケータ引数が非推論コンテキストとなり、アロケータの型はコピー/ムーブ元のみから推論されるようになる。
+
 
 ## 例
 ```cpp example
@@ -185,3 +193,5 @@ c7 : {1 2 3 }
 - [LWG 2210. Missing allocator-extended constructor for allocator-aware containers](http://cplusplus.github.io/LWG/lwg-defects.html#2210)  
 	`explicit deque(size_type n)` にアロケータ引数を追加するきっかけとなったレポート  
 	なお、Discussion の例はアロケータの型が誤っているので注意
+- [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
+    - C++23でのアロケータ引数を`type_identity_t`で包む変更

reference/forward_list/forward_list/op_constructor.md

@@ -27,8 +27,13 @@ forward_list(InputIterator first,
 forward_list(const forward_list& x);                     // (6) C++11
 forward_list(forward_list&& x);                          // (7) C++11
 
-forward_list(const forward_list& x, const Allocator& a); // (8) C++11
-forward_list(forward_list&& x, const Allocator& a);      // (9) C++11
+forward_list(const forward_list& x, const Allocator& a);            // (8) C++11
+forward_list(const forward_list& x,
+             const type_identity_t<Allocator>& a);                  // (8) C++23
+
+forward_list(forward_list&& x, const Allocator& a);                // (9) C++11
+forward_list(forward_list&& x,
+             const type_identity_t<Allocator>& a);                  // (9) C++23
 
 forward_list(initializer_list<T> il,
              const Allocator& a = Allocator());          // (10) C++11
@@ -37,6 +42,7 @@ template <container-compatible-range<T> R>
 forward_list(from_range_t, R&& rg,
              const Allocator& a = Allocator());          // (11) C++23
 ```
+* type_identity_t[link /reference/type_traits/type_identity.md]
 * initializer_list[link /reference/initializer_list/initializer_list.md]
 * from_range_t[link ../../ranges/from_range_t.md]
 
@@ -104,6 +110,9 @@ forward_list(from_range_t, R&& rg,
     * std::scoped_allocator_adaptor[link ../../scoped_allocator/scoped_allocator_adaptor.md]
     * emplace_back[link ../../list/list/emplace_back.md]
 
+- C++23 では、(8) と (9) のアロケータパラメータの型が `const Allocator&` から `const type_identity_t<Allocator>&` に変更された。
+    これは、クラステンプレートのテンプレート引数推論 (CTAD) の際に、コピー/ムーブ元の `forward_list` から推論される `Allocator` と、アロケータ引数から推論される型が異なる場合に推論が失敗する問題を修正するためである。[`type_identity_t`](/reference/type_traits/type_identity.md) で包むことで、アロケータ引数が非推論コンテキストとなり、アロケータの型はコピー/ムーブ元のみから推論されるようになる。
+
 
 ## 例
 ```cpp example
@@ -191,3 +200,5 @@ ls7 : 1 2 3
 - [LWG 2210. Missing allocator-extended constructor for allocator-aware containers](http://cplusplus.github.io/LWG/lwg-defects.html#2210)  
     `explicit forward_list(size_type n)` にアロケータ引数を追加するきっかけとなったレポート  
     なお、Discussion の例はアロケータの型が誤っているので注意
+- [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
+    - C++23でのアロケータ引数を`type_identity_t`で包む変更

reference/list/list/op_constructor.md

@@ -24,8 +24,12 @@ list(InputIterator first, InputIterator last,
 
 list(const list& x);                             // (6)
 list(list&& x);                                  // (7) C++11 から
-list(const list& x, const Allocator& a);         // (8) C++11 から
-list(list&& x, const Allocator& a);              // (9) C++11 から
+list(const list& x, const Allocator& a);                    // (8) C++11
+list(const list& x,
+     const type_identity_t<Allocator>& a);                  // (8) C++23
+
+list(list&& x, const Allocator& a);                         // (9) C++11
+list(list&& x, const type_identity_t<Allocator>& a);        // (9) C++23
 
 list(initializer_list<T> il,
      const Allocator& a = Allocator());          // (10) C++11 から
@@ -34,6 +38,7 @@ template <container-compatible-range<T> R>
 list(from_range_t, R&& rg,
      const Allocator& a = Allocator());          // (11) C++23 から
 ```
+* type_identity_t[link /reference/type_traits/type_identity.md]
 * initializer_list[link /reference/initializer_list/initializer_list.md]
 * from_range_t[link /reference/ranges/from_range_t.md]
 
@@ -100,6 +105,9 @@ list オブジェクトの構築
     * std::scoped_allocator_adaptor[link ../../scoped_allocator/scoped_allocator_adaptor.md]
     * v.emplace_back[link /reference/vector/vector/emplace_back.md]
 
+- C++23 では、(8) と (9) のアロケータパラメータの型が `const Allocator&` から `const type_identity_t<Allocator>&` に変更された。
+	これは、クラステンプレートのテンプレート引数推論 (CTAD) の際に、コピー/ムーブ元の `list` から推論される `Allocator` と、アロケータ引数から推論される型が異なる場合に推論が失敗する問題を修正するためである。[`type_identity_t`](/reference/type_traits/type_identity.md) で包むことで、アロケータ引数が非推論コンテキストとなり、アロケータの型はコピー/ムーブ元のみから推論されるようになる。
+
 
 ## 例
 ```cpp example
@@ -173,3 +181,5 @@ ls7 : 1 2 3
 - [LWG 2210. Missing allocator-extended constructor for allocator-aware containers](http://cplusplus.github.io/LWG/lwg-defects.html#2210)  
 	`explicit list(size_type n)` にアロケータ引数を追加するきっかけとなったレポート  
 	なお、Discussion の例はアロケータの型が誤っているので注意
+- [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
+    - C++23でのアロケータ引数を`type_identity_t`で包む変更

reference/map/map/op_constructor.md

@@ -28,11 +28,14 @@ map(InputIterator first,
 
 map(const map& x);                                     // (6)
 
-map(const map& x, const Allocator& alloc);             // (7) C++11 から
+map(const map& x, const Allocator& alloc);                  // (7) C++11
+map(const map& x,
+    const type_identity_t<Allocator>& alloc);               // (7) C++23
 
-map(map&& y);                                          // (8) C++11 から
+map(map&& y);                                               // (8) C++11 から
 
-map(map&& y, const Allocator& alloc);                  // (9) C++11 から
+map(map&& y, const Allocator& alloc);                       // (9) C++11
+map(map&& y, const type_identity_t<Allocator>& alloc);      // (9) C++23
 
 map(initializer_list<value_type> init,
     const Compare& comp = Compare(),
@@ -50,6 +53,7 @@ template <container-compatible-range <value_type> R>
 map(from_range_t, R&& rg,
     const Allocator& alloc);                           // (13) C++23 から
 ```
+* type_identity_t[link /reference/type_traits/type_identity.md]
 * initializer_list[link ../../initializer_list.md]
 * from_range_t[link ../../ranges/from_range_t.md]
 
@@ -120,6 +124,9 @@ map(from_range_t, R&& rg,
     なお、C++14 では同様の理由で (11) の形式も新たに追加されているが、こちらは存在しなくてもエラーとはならない。  
     （`map(init, alloc)` の形式の構築では、(11) の形式が無い場合でも (10) の形式を用いて `init` から一時 `map` が構築され、`alloc` と共に (9) の形式に引き渡される）
 
+- C++23 では、(7) と (9) のアロケータパラメータの型が `const Allocator&` から `const type_identity_t<Allocator>&` に変更された。
+    これは、クラステンプレートのテンプレート引数推論 (CTAD) の際に、コピー/ムーブ元の `map` から推論される `Allocator` と、アロケータ引数から推論される型が異なる場合に推論が失敗する問題を修正するためである。[`type_identity_t`](/reference/type_traits/type_identity.md) で包むことで、アロケータ引数が非推論コンテキストとなり、アロケータの型はコピー/ムーブ元のみから推論されるようになる。
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -167,3 +174,5 @@ Size of m2: 2
 - [LWG 2210. Missing allocator-extended constructor for allocator-aware containers](http://cplusplus.github.io/LWG/lwg-defects.html#2210)  
     (5), (11) を追加するきっかけとなったレポート  
     なお、Discussion の例はアロケータの型が誤っているので注意
+- [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
+    - C++23でのアロケータ引数を`type_identity_t`で包む変更

reference/map/multimap/op_constructor.md

@@ -29,12 +29,16 @@ multimap(InputIterator first,
 multimap(const multimap& x);                             // (6)
 
 multimap(const multimap& x,
-         const Allocator& alloc);                        // (7) C++11 から
+         const Allocator& alloc);                             // (7) C++11
+multimap(const multimap& x,
+         const type_identity_t<Allocator>& alloc);            // (7) C++23
 
-multimap(multimap&& y);                                  // (8) C++11 から
+multimap(multimap&& y);                                       // (8) C++11 から
 
 multimap(multimap&& y,
-         const Allocator& alloc);                        // (9) C++11 から
+         const Allocator& alloc);                             // (9) C++11
+multimap(multimap&& y,
+         const type_identity_t<Allocator>& alloc);            // (9) C++23
 
 multimap(initializer_list<value_type> init,
          const Compare& comp = Compare(),
@@ -52,6 +56,7 @@ template <container-compatible-range <value_type> R>
 multimap(from_range_t, R&& rg,
          const Allocator& alloc);                        // (13) C++23 から
 ```
+* type_identity_t[link /reference/type_traits/type_identity.md]
 * initializer_list[link ../../initializer_list.md]
 * from_range_t[link ../../ranges/from_range_t.md]
 
@@ -123,6 +128,9 @@ multimap(from_range_t, R&& rg,
     なお、C++14 では同様の理由で (11) の形式も新たに追加されているが、こちらは存在しなくてもエラーとはならない。  
     （`multimap(init, alloc)` の形式の構築では、(11) の形式が無い場合でも (10) の形式を用いて `init` から一時 `multimap` が構築され、`alloc` と共に (9) の形式に引き渡される）
 
+- C++23 では、(7) と (9) のアロケータパラメータの型が `const Allocator&` から `const type_identity_t<Allocator>&` に変更された。
+    これは、クラステンプレートのテンプレート引数推論 (CTAD) の際に、コピー/ムーブ元の `multimap` から推論される `Allocator` と、アロケータ引数から推論される型が異なる場合に推論が失敗する問題を修正するためである。[`type_identity_t`](/reference/type_traits/type_identity.md) で包むことで、アロケータ引数が非推論コンテキストとなり、アロケータの型はコピー/ムーブ元のみから推論されるようになる。
+
 
 ## 例
 ```cpp example
@@ -170,3 +178,5 @@ Size of m2: 3
 - [LWG 2210. Missing allocator-extended constructor for allocator-aware containers](http://cplusplus.github.io/LWG/lwg-defects.html#2210)  
     (5), (11) の形式を追加するきっかけとなったレポート  
     なお、Discussion の例はアロケータの型が誤っているので注意
+- [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
+    - C++23でのアロケータ引数を`type_identity_t`で包む変更

reference/queue/priority_queue/op_deduction_guide.md

@@ -77,6 +77,16 @@ template <class Compare, class Container>
 - (9) : Rangeとアロケータから推論する
 
 
+## 適格要件
+以下のいずれかの条件を満たす場合、コンテナアダプタの推論補助はオーバーロード解決に参加しない：
+
+- `InputIterator`テンプレートパラメータをもち、入力イテレータの要件を満たさない型が推論された場合
+- `Compare`テンプレートパラメータをもち、アロケータとして適格な型が推論された場合 (C++23)
+- `Container`テンプレートパラメータをもち、アロケータとして適格な型が推論された場合 (C++23)
+- `Container`テンプレートパラメータをもたず、`Allocator`テンプレートパラメータをもち、アロケータとして適格でない型が推論された場合 (C++23)
+- `Container`と`Allocator`の両方のテンプレートパラメータをもち、[`uses_allocator_v`](/reference/memory/uses_allocator.md)`<Container, Allocator>`が`false`の場合
+
+
 ## 例
 ```cpp example
 #include <queue>
@@ -120,3 +130,5 @@ int main()
 
 ## 参照
 - [P0433R2 Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0433r2.html)
+- [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
+    - C++23での推論補助の制約についての変更

reference/queue/queue/op_deduction_guide.md

@@ -51,6 +51,15 @@ namespace std {
 - (6) : Rangeとアロケータからの推論する。
 
 
+## 適格要件
+以下のいずれかの条件を満たす場合、コンテナアダプタの推論補助はオーバーロード解決に参加しない：
+
+- `InputIterator`テンプレートパラメータをもち、入力イテレータの要件を満たさない型が推論された場合
+- `Container`テンプレートパラメータをもち、アロケータとして適格な型が推論された場合 (C++23)
+- `Container`テンプレートパラメータをもたず、`Allocator`テンプレートパラメータをもち、アロケータとして適格でない型が推論された場合 (C++23)
+- `Container`と`Allocator`の両方のテンプレートパラメータをもち、[`uses_allocator_v`](/reference/memory/uses_allocator.md)`<Container, Allocator>`が`false`の場合
+
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -104,3 +113,5 @@ int main()
 - [P0433R2 Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0433r2.html)
 - [P1425R4 Iterators pair constructors for stack and queue](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1425r4.pdf)
     - C++23でのイテレータペアへの対応
+- [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
+    - C++23での推論補助の制約についての変更