26.3 Range access [range.access] C++N4910:2022 (651) p1035.cpp

# はじめに(Introduction)

N4910  Working Draft, Standard for Programming Language C++

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf

n4910は、ISO/IEC JTC1 SC22 WG21の作業原案(Working Draft)です。
公式のISO/IEC 14882原本ではありません。
ISO/IEC JTC1 SC22 WG21では、可能な限り作業文書を公開し、幅広い意見を求めています。
一連の記事はコード断片をコンパイルできる形にする方法を検討してコンパイル、リンク、実行して、規格案の原文と処理系(g++, Clang++)との違いを確認し、技術内容を検討し、ISO/IEC JTC1 SC22 WG21にフィードバックするために用います。
また、CERT C++, MISRA C++等のコーディング標準のコード断片をコンパイルする際の参考にさせていただこうと考えています。CERT C++, MISRA C++が標準化の動きとの時間的なずれがあれば確認できれば幸いです。また、boostライブラリとの関連、Linux OS, TOPPERSカーネル、g++(GCC), clang++(LLVM）との関係も調査中です。
何か、抜け漏れ、耳より情報がありましたらおしらせくださると幸いです。

 <この項は書きかけです。順次追記します。>

## 背景(back ground)
C/C++でコンパイルエラーが出ると、途方にくれることがしばしばあります。
何回かに１回は、該当するエラーが検索できます。
ただ、条件が違っていて、そこでの修正方法では目的を達成しないこともしばしばです。いろいろな条件のコンパイルエラーとその対応方法について、広く記録することによって、いつか同じエラーに遭遇した時にやくに立つことを目指しています。

この半年の間で、三度、自分のネットでの記録に助けられたことがあります。
また過去に解決できなかった記録を１０種類以上、最近になって解決できたことがあります。それは、主に次の３つの情報に基づいています。

https://stackoverflow.com

http://ja.cppreference.com/

cpprefjp - C++日本語リファレンス

https://cpprefjp.github.io/

コンパイラの実装状況

https://cpprefjp.github.io/implementation-status.html

また
https://researchmap.jp/joub9b3my-1797580/#_1797580
に記載したサイトのお世話になっています。

## 作業方針(sequence)
Clang++では-std=c++03, C++2bの2種類
g++では-std=c++03, c++2bの２種類
でコンパイルし、

１）コンパイルエラーを収集する。
２）コンパイルエラーをなくす方法を検討する。
コンパイルエラーになる例を示すだけが目的のコードは、コンパイルエラーをなくすのではなく、コンパイルエラーの種類を収集するだけにする。
文法を示すのが目的のコード場合に、コンパイルエラーをなくすのに手間がかかる場合は、順次作業します。
３）リンクエラーをなくす方法を検討する。
文法を示すのが目的のコード場合に、リンクエラーをなくすのに手間がかかる場合は、順次作業します。
４）意味のある出力を作る。
コンパイル、リンクが通っても、意味のある出力を示そうとすると、コンパイル・リンクエラーが出て収拾できそうにない場合がある。順次作業します。

１）だけのものから４）まで進んだものと色々ある状態です。一歩でも前に進むご助言をお待ちしています。「検討事項」の欄に現状を記録するようにしています。

### C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list  

https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

### C++N4741, 2018 Standard Working Draft on ISO/IEC 14882 sample code compile list
https://qiita.com/kaizen_nagoya/items/3294c014044550896010

### C++N4606, 2016符号断片編纂一覧(example code compile list)
C++N4606, 2016 Working Draft 2016, ISO/IEC 14882, C++ standard(1) Example code compile list
https://qiita.com/kaizen_nagoya/items/df5d62c35bd6ed1c3d43/

### C++N3242, 2011 sample code compile list on clang++ and g++
https://qiita.com/kaizen_nagoya/items/685b5c1a2c17c1bf1318

## 編纂器(Compiler)
### clang++ --version
> Debian clang version 14.0.5-++20220610033153+c12386ae247c-1~exp1~20220610153237.151
Target: x86_64-pc-linux-gnu, Thread model: posix, InstalledDir: /usr/bin

### g++- --version
> g++ (GCC) 12.1.0  Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# 26.3 Range access [range.access] C++N4910:2022 (651) p1035.cpp

## 算譜(source code)

```c++:p1035.cpp
// C++N4910 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf
const char * n4910 = "26.3 Range access [range.access] C++N4910:2022 (651) p1035.cpp";
// Debian clang version 14.0.5-++20220610033153+c12386ae247c-
// g++ (GCC) 12.1.0 Copyright (C) 2022 Free Software Foundation, Inc.
// Edited by Dr. OGAWA Kiyoshi. Compile procedure and results record.
// C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list
// https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

#include "N4910.h"

using namespace std;

// 26.3 Range access [range.access]
// 26.3.1 General [range.access.general]
//  In addition to being available via inclusion of the <ranges> header, the customization point objects in 26.3 are available when <iterator> (25.2) is included.
//  Within 26.3, the reified object of a subexpression E denotes
// — the same object as E if E is a glvalue, or
// — the result of applying the temporary materialization conversion (7.3.5) to E otherwise.
// 26.3.2 ranges::begin [range.access.begin]
//  The name ranges::begin denotes a customization point object
//  Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then:
// — If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges::begin(E) is ill- formed.
// — Otherwise, if T is an array type (9.3.4.5) and remove_all_extents_t<T> is an incomplete type, ranges::begin(E) is ill-formed with no diagnostic required.
// — Otherwise, if T is an array type, ranges::begin(E) is expression-equivalent to t + 0.
// — Otherwise, if auto(t.begin()) is a valid expression whose type models input_or_output_iterator, ranges::begin(E) is expression-equivalent to auto(t.begin()).
// — Otherwise, if T is a class or enumeration type and auto(begin(t)) is a valid expression whose type models input_or_output_iterator with overload resolution performed in a context in which unqualified lookup for begin finds only the declarations
void begin(auto&) = delete;
void begin(const auto&) = delete;
// then ranges::begin(E) is expression-equivalent to auto(begin(t)) with overload resolution performed in the above context.
// — Otherwise, ranges::begin(E) is ill-formed. immediate context of a template instantiation.
//  [Note 2: Whenever ranges::begin(E) is a valid expression, its type models input_or_output_iterator.
//  [Note 1: Diagnosable ill-formed cases above result in substitution failure when ranges::begin(E) appears in the
// 26.3.3 ranges::end [range.access.end]
//  The name ranges::end denotes a customization point object (16.3.3.3.6).
//  Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then: immediate context of a template instantiation. —end note]
//  [Note 2 : Whenever ranges::end(E) is a valid expression, the types S and I of ranges::end(E) and ranges::begin(E) model sentinel_for<S, I>. —end note]
// 26.3.4 ranges::cbegin [range.access.cbegin]
//  The name ranges::cbegin denotes a customization point object (16.3.3.3.6). The expression ranges:: cbegin(E) for a subexpression E of type T is expression-equivalent to:
// — ranges::begin(static_cast<const T&>(E)) if E is an lvalue.
//  The name ranges::cend denotes a customization point object (16.3.3.3.6). The expression ranges::cend(E) for a subexpression E of type T is expression-equivalent to:
// — Otherwise, ranges::begin(static_cast<const T&&>(E)).
// [Note 1 : Whenever ranges::cbegin(E) is a valid expression, its type models input_or_output_iterator.
// 26.3.5 ranges::cend [range.access.cend]
// — ranges::end(static_cast<const T&>(E)) if E is an lvalue.
(1.1) (1.2)
// The name ranges::rbegin denotes a customization point object (16.3.3.3.6).
// Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then:
// — If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges::rbegin(E) is ill-formed.
// — Otherwise, if T is an array type (9.3.4.5) and remove_all_extents_t<T> is an incomplete type, ranges::rbegin(E) is ill-formed with no diagnostic required.
// — Otherwise, if auto(t.rbegin()) is a valid expression whose type models input_or_output_iterator, ranges::rbegin(E) is expression-equivalent to auto(t.rbegin()).
// — Otherwise, ranges::end(static_cast<const T&&>(E)).
//  [Note 1: Whenever ranges::cend(E) is a valid expression, the types S and I of the expressions ranges::cend(E) and ranges::cbegin(E) model sentinel_for<S, I>.
// 26.3.6 ranges::rbegin [range.access.rbegin]
// — Otherwise, if T is a class or enumeration type and auto(rbegin(t)) is a valid expression whose type models input_or_output_iterator with overload resolution performed in a context in which unqualified lookup for rbegin finds only the declarations
void rbegin(auto&) = delete;
void rbegin(const auto&) = delete;
// then ranges::rbegin(E) is expression-equivalent to auto(rbegin(t)) with overload resolution per- formed in the above context.
// — Otherwise, if both ranges::begin(t) and ranges::end(t) are valid expressions of the same type which models bidirectional_iterator (25.3.4.12), ranges::rbegin(E) is expression-equivalent to make_reverse_iterator(ranges::end(t)).
// — If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges::rend(E) is ill- formed.
// — Otherwise, if T is an array type (9.3.4.5) and remove_all_extents_t<T> is an incomplete type, ranges::rend(E) is ill-formed with no diagnostic required.
// — Otherwise, if auto(t.rend()) is a valid expression whose type models sentinel_for<decltype( ranges::rbegin(E))> then ranges::rend(E) is expression-equivalent to auto(t.rend()).
// — Otherwise, if T is a class or enumeration type and auto(rend(t)) is a valid expression whose type models sentinel_for<decltype(ranges::rbegin(E))> with overload resolution performed in a context in which unqualified lookup for rend finds only the declarations
void rend(auto&) = delete;
void rend(const auto&) = delete;
// then ranges::rend(E) is expression-equivalent to auto(rend(t)) with overload resolution performed in the above context.
// — Otherwise, if both ranges::begin(t) and ranges::end(t) are valid expressions of the same type which models bidirectional_iterator (25.3.4.12), then ranges::rend(E) is expression-equivalent to make_reverse_iterator(ranges::begin(t)).
// — Otherwise, ranges::rbegin(E) is ill-formed. immediate context of a template instantiation. —end note]
//  [Note 2 : Whenever ranges::rbegin(E) is a valid expression, its type models input_or_output_iterator. — end note ]
// 26.3.7 ranges::rend [range.access.rend]
//  The name ranges::rend denotes a customization point object
//  Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then:
//  [Note 1: Diagnosable ill-formed cases above result in substitution failure when ranges::rbegin(E) appears in the
// — Otherwise, ranges::rend(E) is ill-formed. immediate context of a template instantiation. —end note]
//  [Note 2: Whenever ranges::rend(E) is a valid expression, the types S and I of the expressions ranges::rend(E) and ranges::rbegin(E) model sentinel_for<S, I>. —end note]
// 26.3.8 ranges::crbegin [range.access.crbegin]
//  The name ranges::crbegin denotes a customization point object (16.3.3.3.6). The expression ranges:: crbegin(E) for a subexpression E of type T is expression-equivalent to: — ranges::rbegin(static_cast<const T&>(E)) if E is an lvalue. — Otherwise, ranges::rbegin(static_cast<const T&&>(E)).
// [Note 1 : Whenever ranges::crbegin(E) is a valid expression, its type models input_or_output_iterator.
// 6.3.9 ranges::crend [range.access.crend]
//  The name ranges::crend denotes a customization point object (16.3.3.3.6). The expression ranges:: crend(E) for a subexpression E of type T is expression-equivalent to:
//  [Note 1: Diagnosable ill-formed cases above result in substitution failure when ranges::rend(E) appears in the
// — If T is an array of unknown bound (9.3.4.5), ranges::empty(E) is ill-formed.
// — Otherwise, if bool(t.empty()) is a valid expression, ranges::empty(E) is expression-equivalent to bool(t.empty()).
// — Otherwise, if (ranges::size(t) == 0) is a valid expression, ranges::empty(E) is expression-equiva- lent to (ranges::size(t) == 0).
// — Otherwise, if bool(ranges::begin(t) == ranges::end(t)) is a valid expression and the type of ranges::begin(t) models forward_iterator, ranges::empty(E) is expression-equivalent to bool( ranges::begin(t) == ranges::end(t)).
// — Otherwise, ranges::empty(E) is ill-formed.
// [Note 1: Diagnosable ill-formed cases above result in substitution failure when ranges::empty(E) appears in the
// — ranges::rend(static_cast<const T&>(E)) if E is an lvalue.
//  The name ranges::size denotes a customization point object (16.3.3.3.6).
//  Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then:
// — If T is an array of unknown bound (9.3.4.5), ranges::size(E) is ill-formed.
// — Otherwise, if T is an array type, ranges::size(E) is expression-equivalent to auto(extent_v<T>).
// — Otherwise, if disable_sized_range<remove_cv_t<T>> (26.4.3) is false and auto(t.size()) is a valid expression of integer-like type (25.3.4.4), ranges::size(E) is expression-equivalent to auto( t.size()).
// — Otherwise, if T is a class or enumeration type, disable_sized_range<remove_cv_t<T>> is false and auto(size(t)) is a valid expression of integer-like type with overload resolution performed in a context in which unqualified lookup for size finds only the declarations
void size(auto&) = delete;
void size(const auto&) = delete;
// then ranges::size(E) is expression-equivalent to auto(size(t)) with overload resolution performed in the above context.
// — Otherwise, if to-unsigned-like(ranges::end(t) - ranges::begin(t)) (26.2) is a valid expres- sion and the types I and S of ranges::begin(t) and ranges::end(t) (respectively) model both sized_sentinel_for<S, I> (25.3.4.8) and forward_iterator<I>, then ranges::size(E) is expres- sion-equivalent to to-unsigned-like(ranges::end(t) - ranges::begin(t)).
// — Otherwise, ranges::size(E) is ill-formed.
// 1: Diagnosable ill-formed cases above result in substitution failure when ranges::size(E) appears in the
// — Otherwise, ranges::rend(static_cast<const T&&>(E)).
//  [Note 1: Whenever ranges::crend(E) is a valid expression, the types S and I of the expressions ranges::crend(E) and ranges::crbegin(E) model sentinel_for<S, I>.
// 26.3.10 ranges::size [range.prim.size]
// immediate context of a template instantiation.
//  [Note 2 : Whenever ranges::size(E) is a valid expression, its type is integer-like. — end note ]
// 26.3.11 ranges::ssize [range.prim.ssize]
//  The name ranges::ssize denotes a customization point object (16.3.3.3.6).
//  Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. If ranges::size(t) is ill-formed, ranges::ssize(E) is ill-formed. Otherwise let D be make-signed-like-t <decltype(ranges:: size(t))>, or ptrdiff_t if it is wider than that type; ranges::ssize(E) is expression-equivalent to static_cast<D>(ranges::size(t)).
// 26.3.12 ranges::empty [range.prim.empty]
// The name ranges::empty denotes a customization point object (16.3.3.3.6).
//  Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then:
//  [Note immediate context of a template instantiation.
//  [Note 2 : Whenever ranges::empty(E) is a valid expression, it has type bool.
// — If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges::data(E) is ill- formed.
// — Otherwise, if T is an array type (9.3.4.5) and remove_all_extents_t<T> is an incomplete type, ranges::data(E) is ill-formed with no diagnostic required.
// — Otherwise, if auto(t.data()) is a valid expression of pointer to object type, ranges::data(E) is expression-equivalent to auto(t.data()).
// — Otherwise, if ranges::begin(t) is a valid expression whose type models contiguous_iterator, ranges::data(E) is expression-equivalent to to_address(ranges::begin(t)).
// — ranges::data(static_cast<const T&>(E)) if E is an lvalue.
// 6.3.13 ranges::data [range.prim.data]
// The name ranges::data denotes a customization point object (16.3.3.3.6).
//  Given a subexpression E with type T, let t be an lvalue that denotes the reified object for E. Then:
// — Otherwise, ranges::data(E) is ill-formed. immediate context of a template instantiation. —end note]
//  [Note 2 : Whenever ranges::data(E) is a valid expression, it has pointer to object type. 26.3.14 ranges::cdata
//  [Note 1: Diagnosable ill-formed cases above result in substitution failure when ranges::data(E) appears in the
// The name ranges::cdata denotes a customization point object (16.3.3.3.6). The expression ranges:: cdata(E) for a subexpression E of type T is expression-equivalent to:
// — Otherwise, ranges::data(static_cast<const T&&>(E)).
// [Note 1 : Whenever ranges::cdata(E) is a valid expression, it has pointer to object type.
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

## 編纂・実行結果(compile and go)

```ubuntu:bash
$ clang++ p1035.cpp -std=03 -o p1035l -I. -Wall
In file included from p1035.cpp:10:
In file included from ./N4910.h:11:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/atomic:38:
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/c++0x_warning.h:32:2: error: This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
#error This file requires compiler and library support \
 ^
p1035.cpp:28:17: warning: 'auto' type specifier is a C++11 extension [-Wc++11-extensions]
     void begin(auto&) = delete;
                ^
p1035.cpp:28:17: error: 'auto' not allowed in function prototype
     void begin(auto&) = delete;
                ^~~~
p1035.cpp:28:26: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
     void begin(auto&) = delete;
                         ^
p1035.cpp:29:23: warning: 'auto' type specifier is a C++11 extension [-Wc++11-extensions]
     void begin(const auto&) = delete;
                      ^
p1035.cpp:29:23: error: 'auto' not allowed in function prototype
     void begin(const auto&) = delete;
                      ^~~~
p1035.cpp:29:32: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
     void begin(const auto&) = delete;
                               ^
p1035.cpp:46:2: error: expected unqualified-id
(1.1) (1.2)
 ^
p1035.cpp:46:2: error: expected ')'
p1035.cpp:46:1: note: to match this '('
(1.1) (1.2)
^
p1035.cpp:57:24: warning: 'auto' type specifier is a C++11 extension [-Wc++11-extensions]
     void rbegin(const auto&) = delete;
                       ^
p1035.cpp:57:24: error: 'auto' not allowed in function prototype
     void rbegin(const auto&) = delete;
                       ^~~~
p1035.cpp:57:33: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
     void rbegin(const auto&) = delete;
                                ^
p1035.cpp:64:16: warning: 'auto' type specifier is a C++11 extension [-Wc++11-extensions]
     void rend(auto&) = delete;
               ^
p1035.cpp:64:16: error: 'auto' not allowed in function prototype
     void rend(auto&) = delete;
               ^~~~
p1035.cpp:64:25: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
     void rend(auto&) = delete;
                        ^
p1035.cpp:65:22: warning: 'auto' type specifier is a C++11 extension [-Wc++11-extensions]
     void rend(const auto&) = delete;
                     ^
p1035.cpp:65:22: error: 'auto' not allowed in function prototype
     void rend(const auto&) = delete;
                     ^~~~
p1035.cpp:65:31: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
     void rend(const auto&) = delete;
                              ^
p1035.cpp:95:16: warning: 'auto' type specifier is a C++11 extension [-Wc++11-extensions]
     void size(auto&) = delete;
               ^
p1035.cpp:95:16: error: 'auto' not allowed in function prototype
     void size(auto&) = delete;
               ^~~~
p1035.cpp:95:25: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
     void size(auto&) = delete;
                        ^
p1035.cpp:96:22: warning: 'auto' type specifier is a C++11 extension [-Wc++11-extensions]
     void size(const auto&) = delete;
                     ^
p1035.cpp:96:22: error: 'auto' not allowed in function prototype
     void size(const auto&) = delete;
                     ^~~~
p1035.cpp:96:31: warning: deleted function definitions are a C++11 extension [-Wc++11-extensions]
     void size(const auto&) = delete;
                              ^
14 warnings and 10 errors generated.
$ clang++ p1035.cpp -std=2b -o p1035l -I. -Wall
p1035.cpp:46:2: error: expected unqualified-id
(1.1) (1.2)
 ^
p1035.cpp:46:2: error: expected ')'
p1035.cpp:46:1: note: to match this '('
(1.1) (1.2)
^
2 errors generated.

$ g++ p1035.cpp -std=03 -o p1035g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p1035.cpp:10:
/usr/local/include/c++/12.1.0/bits/c++0x_warning.h:32:2: error: #error This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
   32 | #error This file requires compiler and library support \
      |  ^~~~~
p1035.cpp:28:17: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
   28 |      void begin(auto&) = delete;
      |                 ^~~~
      |                 ----
p1035.cpp:28:21: error: ISO C++ forbids declaration of 'parameter' with no type [-fpermissive]
   28 |      void begin(auto&) = delete;
      |                     ^
p1035.cpp:28:26: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   28 |      void begin(auto&) = delete;
      |                          ^~~~~~
p1035.cpp:29:23: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
   29 |      void begin(const auto&) = delete;
      |                       ^~~~
      |                       ----
p1035.cpp:29:27: error: ISO C++ forbids declaration of 'parameter' with no type [-fpermissive]
   29 |      void begin(const auto&) = delete;
      |                           ^
p1035.cpp:29:32: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   29 |      void begin(const auto&) = delete;
      |                                ^~~~~~
p1035.cpp:46:2: error: expected unqualified-id before numeric constant
   46 | (1.1) (1.2)
      |  ^~~
p1035.cpp:46:2: error: expected ')' before numeric constant
   46 | (1.1) (1.2)
      | ~^~~
      |  )
p1035.cpp:57:24: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
   57 |      void rbegin(const auto&) = delete;
      |                        ^~~~
      |                        ----
p1035.cpp:57:28: error: ISO C++ forbids declaration of 'parameter' with no type [-fpermissive]
   57 |      void rbegin(const auto&) = delete;
      |                            ^
p1035.cpp:57:33: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   57 |      void rbegin(const auto&) = delete;
      |                                 ^~~~~~
p1035.cpp:64:16: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
   64 |      void rend(auto&) = delete;
      |                ^~~~
      |                ----
p1035.cpp:64:20: error: ISO C++ forbids declaration of 'parameter' with no type [-fpermissive]
   64 |      void rend(auto&) = delete;
      |                    ^
p1035.cpp:64:25: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   64 |      void rend(auto&) = delete;
      |                         ^~~~~~
p1035.cpp:65:22: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
   65 |      void rend(const auto&) = delete;
      |                      ^~~~
      |                      ----
p1035.cpp:65:26: error: ISO C++ forbids declaration of 'parameter' with no type [-fpermissive]
   65 |      void rend(const auto&) = delete;
      |                          ^
p1035.cpp:65:31: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   65 |      void rend(const auto&) = delete;
      |                               ^~~~~~
p1035.cpp:95:16: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
   95 |      void size(auto&) = delete;
      |                ^~~~
      |                ----
p1035.cpp:95:20: error: ISO C++ forbids declaration of 'parameter' with no type [-fpermissive]
   95 |      void size(auto&) = delete;
      |                    ^
p1035.cpp:95:25: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   95 |      void size(auto&) = delete;
      |                         ^~~~~~
p1035.cpp:96:22: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
   96 |      void size(const auto&) = delete;
      |                      ^~~~
      |                      ----
p1035.cpp:96:26: error: ISO C++ forbids declaration of 'parameter' with no type [-fpermissive]
   96 |      void size(const auto&) = delete;
      |                          ^
p1035.cpp:96:31: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++11' [-Wc++11-extensions]
   96 |      void size(const auto&) = delete;
      |                               ^~~~~~

$ g++ p1035.cpp -std=2b -o p1035g -I. -Wall
p1035.cpp:46:2: error: expected unqualified-id before numeric constant
   46 | (1.1) (1.2)
      |  ^~~
p1035.cpp:46:2: error: expected ')' before numeric constant
   46 | (1.1) (1.2)
      | ~^~~
      |  )

```

## 検討事項(agenda)
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。

<!-- リンクエラーの解説をする。clang++とg++の比較。意味のある出力。
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。-->

# 参考資料(reference)


関連する自己参照以外は、こちらの先頭に移転。

C言語（C++)に対する誤解、曲解、無理解、爽快。

https://qiita.com/kaizen_nagoya/items/3f3992c9722c1cee2e3a

#include "N4910.h"

https://qiita.com/kaizen_nagoya/items/163a47cef7d6bb1c33a8

C++N4910資料の改善点

https://qiita.com/kaizen_nagoya/items/fb4ceb5d117a54641af3

dockerにclang

https://qiita.com/kaizen_nagoya/items/8829ffeee397eda50e80

docker gnu(gcc/g++) and llvm(clang/clang++)

https://qiita.com/drafts/059874ea39c4de64c0f7

コンパイル用shell script C版(clangとgcc)とC++版(clang++とg++)

https://qiita.com/kaizen_nagoya/items/74220c0577a512c2d7da


C++N4910:2022 tag follower 300人超えました。ありがとうございます。

https://qiita.com/kaizen_nagoya/items/a63fb96d351ac5c16ff7

astyle 使ってみた

https://qiita.com/kaizen_nagoya/items/3c9a87a781d53a1a23f3

DoCAP（ドゥーキャップ）って何ですか？

https://qiita.com/kaizen_nagoya/items/47e0e6509ab792c43327

小川メソッド　覚え（書きかけ）

https://qiita.com/kaizen_nagoya/items/3593d72eca551742df68

 ＜この記事は個人の過去の経験に基づく個人の感想です。現在所属する組織、業務とは関係がありません。＞

# 文書履歴(document history)
ver. 0.01 初稿 　20220811