はじめに(Introduction)
N4910 Working Draft, Standard for Programming Language C++
http://www.open-std./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
C++N4741, 2018 Standard Working Draft on ISO/IEC 14882 sample code compile list
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++
編纂器(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.
23.4 String classes [string.classes] C++N4910:2022 (636) p808.cpp
算譜(source code)
p808.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 = "23.4 String classes [string.classes] C++N4910:2022 (636) p808.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;
// 23.4.2 Header <string> synopsis [string.syn]
#include <compare> // see 17.11.1
#include <initializer_list> // see 17.10.2
namespace std {
// 23.2, character traits
template<class charT> struct char_traits;
template<> struct char_traits<char>;
template<> struct char_traits<char8_t>;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
template<> struct char_traits<wchar_t>;
// 23.4.3, basic_string
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
class basic_string;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const charT* lhs,
basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs,
const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs,
basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
charT rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
charT rhs);
template<class charT, class traits, class Allocator>
constexpr bool
operator==(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
// 23.4.4.3, swap
template<class charT, class traits, class Allocator>
constexpr void
swap(basic_string<charT, traits, Allocator>& lhs,
basic_string<charT, traits, Allocator>& rhs)
noexcept(noexcept(lhs.swap(rhs)));
// 23.4.4.4, inserters and extractors
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
basic_string<charT, traits, Allocator>& str,
charT delim);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
basic_string<charT, traits, Allocator>& str,
charT delim);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
basic_string<charT, traits, Allocator>& str);
// 23.4.4.5, erasure
template<class charT, class traits, class Allocator, class U>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase(basic_string<charT, traits, Allocator>& c, const U& value);
template<class charT, class traits, class Allocator, class Predicate>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
// basic_string typedef-names
using string = basic_string<char>;
using u8string = basic_string<char8_t>;
using u16string = basic_string<char16_t>;
using u32string = basic_string<char32_t>;
using wstring = basic_string<wchar_t>;
// 23.4.5, numeric conversions
int stoi(const string& str, size_t* idx = nullptr, int base = 10);
long stol(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
float stof(const string& str, size_t* idx = nullptr);
double stod(const string& str, size_t* idx = nullptr);
long double stold(const string& str, size_t* idx = nullptr);
string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);
int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
float stof(const wstring& str, size_t* idx = nullptr);
double stod(const wstring& str, size_t* idx = nullptr);
long double stold(const wstring& str, size_t* idx = nullptr);
wstring to_wstring(int val);
wstring to_wstring(unsigned val);
wstring to_wstring(long val);
wstring to_wstring(unsigned long val);
wstring to_wstring(long long val);
wstring to_wstring(unsigned long long val);
wstring to_wstring(float val);
wstring to_wstring(double val);
wstring to_wstring(long double val);
namespace pmr {
template<class charT, class traits = char_traits<charT>>
using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
using string = basic_string<char>;
using u8string = basic_string<char8_t>;
using u16string = basic_string<char16_t>;
using u32string = basic_string<char32_t>;
using wstring = basic_string<wchar_t>;
}
// 23.4.6, hash support
template<class T> struct hash;
template<> struct hash<string>;
template<> struct hash<u8string>;
template<> struct hash<u16string>;
template<> struct hash<u32string>;
template<> struct hash<wstring>;
template<> struct hash<pmr::string>;
template<> struct hash<pmr::u8string>;
template<> struct hash<pmr::u16string>;
template<> struct hash<pmr::u32string>;
template<> struct hash<pmr::wstring>;
inline namespace literals {
inline namespace string_literals {
// 23.4.7, suffix for basic_string literals
constexpr string operator""s(const char* str, size_t len);
constexpr u8string operator""s(const char8_t* str, size_t len);
constexpr u16string operator""s(const char16_t* str, size_t len);
constexpr u32string operator""s(const char32_t* str, size_t len);
constexpr wstring operator""s(const wchar_t* str, size_t len);
}
}
}
// 23.4.3 Class template basic_string [basic.string]
// 23.4.3.1 General [basic.string.general]
// The class template basic_string describes objects that can store a sequence consisting of a varying number of arbitrary char-like objects with the first element of the sequence at position zero. Such a sequence is also called a “string” if the type of the char-like objects that it holds is clear from context. In the rest of 23.4.3, the type of the char-like objects held in a basic_string object is designated by charT.
// A specialization of basic_string is a contiguous container (24.2.2.1).
// In all cases, [data(), data() + size()] is a valid range, data() + size() points at an object with value charT() (a “null terminator”), and size() <= capacity() is true.
namespace std {
template<class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT>>
class basic_string {
public:
// types
using traits_type = traits;
using value_type = charT;
using allocator_type = Allocator;
using size_type = typename allocator_traits<Allocator>::size_type;
using difference_type = typename allocator_traits<Allocator>::difference_type;
using pointer = typename allocator_traits<Allocator>::pointer;
using const_pointer = typename allocator_traits<Allocator>::const_pointer;
using reference = value_type&;
using const_reference = const value_type&;
using iterator = implementation-defined ; // see 24.2
using const_iterator = implementation-defined ; // see 24.2
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
static constexpr size_type npos = size_type(-1);
// 23.4.3.3, construct/copy/destroy
constexpr basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { } constexpr explicit basic_string(const Allocator& a) noexcept;
constexpr basic_string(const basic_string& str);
constexpr basic_string(basic_string&& str) noexcept;
constexpr basic_string(const basic_string& str, size_type pos,
const Allocator& a = Allocator());
constexpr basic_string(const basic_string& str, size_type pos, size_type n,
const Allocator& a = Allocator());
template<class T>
constexpr basic_string(const T& t, size_type pos, size_type n,
const Allocator& a = Allocator());
template<class T>
constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
constexpr basic_string(const charT* s, const Allocator& a = Allocator());
basic_string(nullptr_t) = delete;
constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
template<class InputIterator>
constexpr basic_string(InputIterator begin, InputIterator end,
const Allocator& a = Allocator());
template<container-compatible-range<charT> R>
constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());
constexpr basic_string(initializer_list<charT>, const Allocator& = Allocator());
constexpr basic_string(const basic_string&, const Allocator&);
constexpr basic_string(basic_string&&, const Allocator&);
constexpr ~basic_string();
constexpr basic_string& operator=(const basic_string& str);
constexpr basic_string& operator=(basic_string&& str)
noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
allocator_traits<Allocator>::is_always_equal::value);
template<class T>
constexpr basic_string& operator=(const T& t);
constexpr basic_string& operator=(const charT* s);
basic_string& operator=(nullptr_t) = delete;
constexpr basic_string& operator=(charT c);
constexpr basic_string& operator=(initializer_list<charT>);
// 23.4.3.4, iterators
constexpr iterator begin() noexcept;
constexpr const_iterator begin() const noexcept;
constexpr iterator end() noexcept;
constexpr const_iterator end() const noexcept;
constexpr reverse_iterator rbegin() noexcept;
constexpr const_reverse_iterator rbegin() const noexcept;
constexpr reverse_iterator rend() noexcept;
constexpr const_reverse_iterator rend() const noexcept;
constexpr const_iterator cbegin() const noexcept;
constexpr const_iterator cend() const noexcept;
constexpr const_reverse_iterator crbegin() const noexcept;
constexpr const_reverse_iterator crend() const noexcept;
// 23.4.3.5, capacity
constexpr size_type size() const noexcept;
constexpr size_type length() const noexcept;
constexpr size_type max_size() const noexcept;
constexpr void resize(size_type n, charT c);
constexpr void resize(size_type n);
template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
constexpr size_type capacity() const noexcept;
constexpr void reserve(size_type res_arg);
constexpr void shrink_to_fit();
constexpr void clear() noexcept;
[[nodiscard]] constexpr bool empty() const noexcept;
// 23.4.3.6, element access
constexpr const_reference operator[](size_type pos) const;
constexpr reference operator[](size_type pos);
constexpr const_reference at(size_type n) const;
constexpr reference at(size_type n);
constexpr const charT& front() const;
constexpr charT& front();
constexpr const charT& back() const;
constexpr charT& back();
// 23.4.3.7, modifiers
constexpr basic_string& operator+=(const basic_string& str);
template<class T>
constexpr basic_string& operator+=(const T& t);
constexpr basic_string& operator+=(const charT* s);
constexpr basic_string& operator+=(charT c);
constexpr basic_string& operator+=(initializer_list<charT>);
constexpr basic_string& append(const basic_string& str);
constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
template<class T>
constexpr basic_string& append(const T& t);
template<class T>
constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
constexpr basic_string& append(const charT* s, size_type n);
constexpr basic_string& append(const charT* s);
constexpr basic_string& append(size_type n, charT c);
template<class InputIterator>
constexpr basic_string& append(InputIterator first, InputIterator last);
template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
constexpr basic_string& append(initializer_list<charT>);
constexpr void push_back(charT c);
constexpr basic_string& assign(const basic_string& str);
constexpr basic_string& assign(basic_string&& str)
noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
allocator_traits<Allocator>::is_always_equal::value);
constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
template<class T>
constexpr basic_string& assign(const T& t);
template<class T>
constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
constexpr basic_string& assign(const charT* s, size_type n);
constexpr basic_string& assign(const charT* s);
constexpr basic_string& assign(size_type n, charT c);
template<class InputIterator>
constexpr basic_string& assign(InputIterator first, InputIterator last);
template<container-compatible-range<charT> R>
constexpr basic_string& assign_range(R&& rg);
constexpr basic_string& assign(initializer_list<charT>);
constexpr basic_string& insert(size_type pos, const basic_string& str);
constexpr basic_string& insert(size_type pos1, const basic_string& str,
size_type pos2, size_type n = npos);
template<class T>
constexpr basic_string& insert(size_type pos, const T& t);
template<class T>
constexpr basic_string& insert(size_type pos1, const T& t,
size_type pos2, size_type n = npos);
constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
constexpr basic_string& insert(size_type pos, const charT* s);
constexpr basic_string& insert(size_type pos, size_type n, charT c);
constexpr iterator insert(const_iterator p, charT c);
constexpr iterator insert(const_iterator p, size_type n, charT c);
template<class InputIterator>
constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
template<container-compatible-range<charT> R>
constexpr iterator insert_range(const_iterator p, R&& rg);
constexpr iterator insert(const_iterator p, initializer_list<charT>);
constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
constexpr iterator erase(const_iterator p);
constexpr iterator erase(const_iterator first, const_iterator last);
constexpr void pop_back();
constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
size_type pos2, size_type n2 = npos);
template<class T>
constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
template<class T>
constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
size_type pos2, size_type n2 = npos);
constexpr basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2);
constexpr basic_string& replace(size_type pos, size_type n1, const charT* s);
constexpr basic_string& replace(size_type pos, size_type n1, size_type n2, charT c);
constexpr basic_string& replace(const_iterator i1, const_iterator i2,
const basic_string& str);
template<class T>
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s,
size_type n);
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
template<class InputIterator>
constexpr basic_string& replace(const_iterator i1, const_iterator i2,
InputIterator j1, InputIterator j2);
template<container-compatible-range<charT> R>
constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
constexpr basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);
constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
constexpr void swap(basic_string& str)
noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
allocator_traits<Allocator>::is_always_equal::value);
// 23.4.3.8, string operations
constexpr const charT* c_str() const noexcept;
constexpr const charT* data() const noexcept;
constexpr charT* data() noexcept;
constexpr operator basic_string_view<charT, traits>() const noexcept;
constexpr allocator_type get_allocator() const noexcept;
template<class T>
constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
constexpr size_type find(const basic_string& str, size_type pos = 0) const noexcept;
constexpr size_type find(const charT* s, size_type pos, size_type n) const;
constexpr size_type find(const charT* s, size_type pos = 0) const;
constexpr size_type find(charT c, size_type pos = 0) const noexcept;
template<class T>
constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);
constexpr size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
constexpr size_type rfind(const charT* s, size_type pos = npos) const;
constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
template<class T>
constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);
constexpr size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
template<class T>
constexpr size_type find_last_of(const T& t,
size_type pos = npos) const noexcept(see below);
constexpr size_type find_last_of(const basic_string& str,
size_type pos = npos) const noexcept;
constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
template<class T>
constexpr size_type find_first_not_of(const T& t,
size_type pos = 0) const noexcept(see below);
constexpr size_type find_first_not_of(const basic_string& str,
size_type pos = 0) const noexcept;
constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
template<class T>
constexpr size_type find_last_not_of(const T& t,
size_type pos = npos) const noexcept(see below);
constexpr size_type find_last_not_of(const basic_string& str,
size_type pos = npos) const noexcept;
constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
template<class T>
constexpr int compare(const T& t) const noexcept(see below);
template<class T>
constexpr int compare(size_type pos1, size_type n1, const T& t) const;
}
template<class T>
constexpr int compare(size_type pos1, size_type n1, const T& t,
size_type pos2, size_type n2 = npos) const;
constexpr int compare(const basic_string& str) const noexcept;
constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
size_type pos2, size_type n2 = npos) const;
constexpr int compare(const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool starts_with(charT x) const noexcept;
constexpr bool starts_with(const charT* x) const;
constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool ends_with(charT x) const noexcept;
constexpr bool ends_with(const charT* x) const;
constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
constexpr bool contains(charT x) const noexcept;
constexpr bool contains(const charT* x) const;
};
template<class InputIterator,
class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
basic_string(InputIterator, InputIterator, Allocator = Allocator())
-> basic_string<typename iterator_traits<InputIterator>::value_type,
char_traits<typename iterator_traits<InputIterator>::value_type>,
Allocator>;
template<ranges::input_range R,
class Allocator = allocator<ranges::range_value_t<R>>>
basic_string(from_range_t, R&&, Allocator = Allocator())
-> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
Allocator>;
template<class charT,
class traits,
class Allocator = allocator<charT>>
explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
template<class charT,
class traits,
class Allocator = allocator<charT>>
basic_string(basic_string_view<charT, traits>,
typename see below::size_type, typename see below::size_type,
const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
// A size_type parameter type in a basic_string deduction guide refers to the size_type member type of the type deduced by the deduction guide.
// The types iterator and const_iterator meet the constexpr iterator requirements (25.3.1).
// 23.4.3.2 General requirements [string.require]
// If any operation would cause size() to exceed max_size(), that operation throws an exception object of type length_error.
// If any member function or operator of basic_string throws an exception, that function or operator has no other effect on the basic_string object.
// In every specialization basic_string<charT, traits, Allocator>, the type allocator_traits<All- ocator>::value_type shall name the same type as charT. Every object of type basic_string<charT, as an argument.213
// — Calling non-const member functions, except operator[], at, data, front, back, begin, rbegin, end, and rend. traits, Allocator> uses an object of type Allocator to allocate and free storage for the contained charT objects as needed. The Allocator object used is obtained as described in 24.2.2.1. In every spe- cialization basic_string<charT, traits, Allocator>, the type traits shall meet the character traits requirements (23.2).
// [Note 1: Every specialization basic_string<charT, traits, Allocator> is an allocator-aware container, but does not use the allocator’s construct and destroy member functions (24.2.2.1).
// [Note 2: The program is ill-formed if traits::char_type is not the same type as charT.
// References, pointers, and iterators referring to the elements of a basic_string sequence may be invalidated by the following uses of that basic_string object:
// — Passing as an argument to any standard library function taking a reference to non-const basic_string
// 23.4.3.3 Constructors and assignment operators [string.cons]
constexpr explicit basic_string(const Allocator& a) noexcept;
// Postconditions: size() is equal to 0. constexpr basic_string(const basic_string& str);
constexpr basic_string(basic_string&& str) noexcept;
// Effects: Constructs an object whose value is that of str prior to this call. Remarks: In the second form, str is left in a valid but unspecified state.
constexpr basic_string(const basic_string& str, size_type pos,
const Allocator& a = Allocator());
constexpr basic_string(const basic_string& str, size_type pos, size_type n,
const Allocator& a = Allocator());
// Effects: Let n be npos for the first overload. Equivalent to: basic_string(basic_string_view<charT, traits>(str).substr(pos, n), a)
template<class T>
constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
// Constraints: is_convertible_v<const T&, basic_string_view<charT, traits>> is true. Effects: Creates a variable, sv, as if by basic_string_view<charT, traits> sv = t; and then behaves the same as:
basic_string(sv.substr(pos, n), a);
template<class T>
constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Creates a variable, sv, as if by basic_string_view<charT, traits> sv = t; and then behaves the same as basic_string(sv.data(), sv.size(), a).
constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
// Preconditions: [s, s + n) is a valid range.
// Effects: Constructs an object whose initial value is the range [s, s + n).
// Postconditions: size() is equal to n, and traits::compare(data(), s, n) is equal to 0.
constexpr basic_string(const charT* s, const Allocator& a = Allocator());
// Constraints: Allocator is a type that qualifies as an allocator (24.2.2.1). [Note 1: This affects class template argument deduction. —end note]
// Effects: Equivalent to: basic_string(s, traits::length(s), a).
// Constraints: Allocator is a type that qualifies as an allocator (24.2.2.1).
constexpr basic_string& operator=(const basic_string& str);
constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
// Constraints: Allocator is a type that qualifies as an allocator (24.2.2.1). [Note 2: This affects class template argument deduction.
// Effects: Constructs an object whose value consists of n copies of c.
template<class InputIterator>
constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Constructs a string from the values in the range [begin, end), as specified in 24.2.4.
template<container-compatible-range<charT> R>
constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
// Effects: Constructs a string from the values in the range rg, as specified in 24.2.4. constexpr basic_string(initializer_list<charT> il, const Allocator& a = Allocator());
// Effects: Equivalent to basic_string(il.begin(), il.end(), a).
constexpr basic_string(const basic_string& str, const Allocator& alloc);
constexpr basic_string(basic_string&& str, const Allocator& alloc);
// Effects: Constructs an object whose value is that of str prior to this call. The stored allocator is constructed from alloc. In the second form, str is left in a valid but unspecified state.
// Throws: The second form throws nothing if alloc == str.get_allocator().
template<class InputIterator,
class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
basic_string(InputIterator, InputIterator, Allocator = Allocator())
-> basic_string<typename iterator_traits<InputIterator>::value_type,
char_traits<typename iterator_traits<InputIterator>::value_type>,
Allocator>;
// Constraints: InputIterator is a type that qualifies as an input iterator, and Allocator is a type that qualifies as an allocator (24.2.2.1).
template<class charT,
class traits,
class Allocator = allocator<charT>>
explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
template<class charT,
class traits,
class Allocator = allocator<charT>>
basic_string(basic_string_view<charT, traits>,
typename see below::size_type, typename see below::size_type,
const Allocator& = Allocator())
-> basic_string<charT, traits, Allocator>;
// Effects: If *this and str are the same object, has no effect. Otherwise, replaces the value of *this with a copy of str.
// Returns: *this.
constexpr basic_string& operator=(basic_string&& str)
noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
allocator_traits<Allocator>::is_always_equal::value);
// Effects: Move assigns as a sequence container (24.2), except that iterators, pointers and references may be invalidated.
// Returns: *this. template<class T>
constexpr basic_string& operator=(const T& t);
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return assign(sv);
constexpr basic_string& operator=(const charT* s);
// Effects: Equivalent to: return *this = basic_string_view<charT, traits>(s);
constexpr basic_string& operator=(charT c);
// Effects: Equivalent to:
return *this = basic_string_view<charT, traits>(addressof(c), 1);
constexpr basic_string& operator=(initializer_list<charT> il);
// Effects: Equivalent to:
return *this = basic_string_view<charT, traits>(il.begin(), il.size());
// 23.4.3.4 Iterator support [string.iterators]
constexpr iterator begin() noexcept;
constexpr const_iterator begin() const noexcept;
constexpr const_iterator cbegin() const noexcept;
// Returns: An iterator referring to the first character in the string.
constexpr iterator end() noexcept;
constexpr const_iterator end() const noexcept;
constexpr const_iterator cend() const noexcept;
// Returns: An iterator which is the past-the-end value.
constexpr reverse_iterator rbegin() noexcept;
constexpr const_reverse_iterator rbegin() const noexcept;
constexpr const_reverse_iterator crbegin() const noexcept;
// Returns: An iterator which is semantically equivalent to reverse_iterator(end()).
constexpr reverse_iterator rend() noexcept;
constexpr const_reverse_iterator rend() const noexcept;
constexpr const_reverse_iterator crend() const noexcept;
// Returns: An iterator which is semantically equivalent to reverse_iterator(begin()).
// 23.4.3.5 Capacity [string.capacity]
constexpr size_type size() const noexcept;
constexpr size_type length() const noexcept;
// Returns: A count of the number of char-like objects currently in the string. Complexity: Constant time.
constexpr size_type max_size() const noexcept;
// Returns: The largest possible number of char-like objects that can be stored in a basic_string. Complexity: Constant time.
constexpr void resize(size_type n, charT c);
// Effects: Alters the value of *this as follows:
// — If n <= size(), erases the last size() - n elements. — If n > size(), appends n - size() copies of c.
constexpr void resize(size_type n);
// Effects: Equivalent to resize(n, charT()).
template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
// Let — o = size() before the call to resize_and_overwrite.
// — k be min(o, n).
// — p be a charT*, such that the range [p, p + n] is valid and this->compare(0, k, p, k) == 0 is true before the call. The values in the range [p + k, p + n] may be indeterminate (6.7.4).
// — OP be the expression std::move(op)(p, n).
// — r = OP.
// Mandates: OP has an integer-like type (25.3.4.4). Preconditions:
// — OP does not throw an exception or modify p or n.
// — r ≥ 0.
// — r ≤ n.
// — After evaluating OP there are no indeterminate values in the range [p, p + r).
// Effects: Evaluates OP, replaces the contents of *this with [p,p + r), and invalidates all pointers and references to the range [p, p + n].
// Recommended practice: Implementations should avoid unnecessary copies and allocations by, for example, making p a pointer into internal storage and by restoring *(p + r) to charT() after evaluating OP.
constexpr size_type capacity() const noexcept;
// Returns: The size of the allocated storage in the string. Complexity: Constant time.
constexpr void reserve(size_type res_arg);
// Effects: A directive that informs a basic_string of a planned change in size, so that the storage allocation can be managed accordingly. After reserve(), capacity() is greater or equal to the argument of reserve if reallocation happens; and equal to the previous value of capacity() otherwise. Reallocation happens at this point if and only if the current capacity is less than the argument of reserve().
// Throws: length_error if res_arg > max_size() or any exceptions thrown by allocator_traits <Allocator>::allocate.
constexpr void shrink_to_fit();
// Effects: shrink_to_fit is a non-binding request to reduce capacity() to size().
// [Note 1: The request is non-binding to allow latitude for implementation-specific optimizations.
// It does not increase capacity(), but may reduce capacity() by causing reallocation.
// Complexity: If the size is not equal to the old capacity, linear in the size of the sequence; otherwise constant.
// Remarks: Reallocation invalidates all the references, pointers, and iterators referring to the elements in the sequence, as well as the past-the-end iterator.
// [Note 2: If no reallocation happens, they remain valid. —end note] constexpr void clear() noexcept;
// Effects: Equivalent to: erase(begin(), end());
[[nodiscard]] constexpr bool empty() const noexcept;
// Effects: Equivalent to: return size() == 0;
// 23.4.3.6 Element access [string.access]
constexpr const_reference operator[](size_type pos) const;
constexpr reference operator[](size_type pos);
// Preconditions: pos <= size().
// Returns: *(begin() + pos) if pos < size(). Otherwise, returns a reference to an object of type charT with value charT(), where modifying the object to any value other than charT() leads to undefined behavior.
// Throws: Nothing. Complexity: Constant time.
constexpr const_reference at(size_type pos) const;
constexpr reference at(size_type pos);
// Returns: operator[](pos).
// Throws: out_of_range if pos >= size().
constexpr const charT& front() const;
constexpr charT& front();
// Preconditions: !empty().
// Effects: Equivalent to: return operator[](0);
constexpr const charT& back() const;
constexpr charT& back();
// Preconditions: !empty().
// Effects: Equivalent to: return operator[](size() - 1);
// 23.4.3.7 Modifiers [string.modifiers]
// 23.4.3.7.1 basic_string::operator+= [string.op.append]
constexpr basic_string& operator+=(const basic_string& str);
// Effects: Equivalent to:
return append(str);
template<class T>
constexpr basic_string& operator+=(const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return append(sv);
constexpr basic_string& operator+=(const charT* s);
// Effects: Equivalent to:
return append(s);
constexpr basic_string& operator+=(charT c);
// Effects: Equivalent to:
return append(size_type{1}, c);
constexpr basic_string& operator+=(initializer_list<charT> il);
// Effects: Equivalent to: return append(il);
// 23.4.3.7.2 basic_string::append [string.append]
constexpr basic_string& append(const basic_string& str);
// Effects: Equivalent to:
return append(str.data(), str.size());
constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
// Effects: Equivalent to:
return append(basic_string_view<charT, traits>(str).substr(pos, n));
template<class T>
constexpr basic_string& append(const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return append(sv.data(), sv.size());
template<class T>
constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return append(sv.substr(pos, n));
constexpr basic_string& append(const charT* s, size_type n);
// Preconditions: [s, s + n) is a valid range.
// Effects: Appends a copy of the range [s, s + n) to the string. Returns: *this.
constexpr basic_string& append(const charT* s);
// Effects: Equivalent to:
return append(s, traits::length(s));
constexpr basic_string& append(size_type n, charT c);
// Effects: Appends n copies of c to the string. Returns: *this.
template<class InputIterator>
constexpr basic_string& append(InputIterator first, InputIterator last);
Constraints:
InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Equivalent to:
return append(basic_string(first, last, get_allocator()));
template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
// Effects: Equivalent to:
return append(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
constexpr basic_string& append(initializer_list<charT> il);
// Effects: Equivalent to:
return append(il.begin(), il.size());
constexpr void push_back(charT c);
// Effects: Equivalent to append(size_type{1}, c).
// 23.4.3.7.3 basic_string::assign [string.assign]
constexpr basic_string& assign(const basic_string& str);
// Effects: Equivalent to:
return *this = str;
constexpr basic_string& assign(basic_string&& str)
noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
allocator_traits<Allocator>::is_always_equal::value);
// Effects: Equivalent to:
return *this = std::move(str);
constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
// Effects: Equivalent to:
return assign(basic_string_view<charT, traits>(str).substr(pos, n));
template<class T>
constexpr basic_string& assign(const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return assign(sv.data(), sv.size());
template<class T>
constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return assign(sv.substr(pos, n));
constexpr basic_string& assign(const charT* s, size_type n);
// Preconditions: [s, s + n) is a valid range.
// Effects: Replaces the string controlled by *this with a copy of the range [s, s + n). Returns: *this.
constexpr basic_string& assign(const charT* s);
// Effects: Equivalent to:
return assign(s, traits::length(s));
constexpr basic_string& assign(initializer_list<charT> il);
// Effects: Equivalent to:
return assign(il.begin(), il.size());
constexpr basic_string& assign(size_type n, charT c);
// Effects: Equivalent to:
clear();
resize(n, c);
return *this;
template<class InputIterator>
constexpr basic_string& assign(InputIterator first, InputIterator last);
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Equivalent to:
return assign(basic_string(first, last, get_allocator()));
template<container-compatible-range<charT> R>
constexpr basic_string& assign_range(R&& rg);
// Effects: Equivalent to:
return assign(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
// 23.4.3.7.4 basic_string::insert [string.insert]
constexpr basic_string& insert(size_type pos, const basic_string& str);
// Effects: Equivalent to:
return insert(pos, str.data(), str.size());
constexpr basic_string& insert(size_type pos1, const basic_string& str,
size_type pos2, size_type n = npos);
// Effects: Equivalent to:
return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
template<class T>
constexpr basic_string& insert(size_type pos, const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return insert(pos, sv.data(), sv.size());
template<class T>
constexpr basic_string& insert(size_type pos1, const T& t,
size_type pos2, size_type n = npos);
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return insert(pos1, sv.substr(pos2, n));
constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
// Preconditions: [s, s + n) is a valid range.
// Effects: Inserts a copy of the range [s, s + n) immediately before the character at position pos if pos < size(), or otherwise at the end of the string. Returns: *this.
// Throws: — out_of_range if pos > size(),
// — length_error if n > max_size() - size(), or
// — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr basic_string& insert(size_type pos, const charT* s);
// Effects: Equivalent to: return insert(pos, s, traits::length(s));
constexpr basic_string& insert(size_type pos, size_type n, charT c);
// Effects: Inserts n copies of c before the character at position pos if pos < size(), or otherwise at the end of the string.
// Returns: *this
// Throws: — out_of_range if pos > size(),
// — length_error if n > max_size() - size(), or
// — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr iterator insert(const_iterator p, charT c);
// Preconditions: p is a valid iterator on *this.
// Effects: Inserts a copy of c at the position p.
// Returns: An iterator which refers to the inserted character.
constexpr iterator insert(const_iterator p, size_type n, charT c);
// Preconditions: p is a valid iterator on *this.
// Effects: Inserts n copies of c at the position p.
// Returns: An iterator which refers to the first inserted character, or p if n == 0.
template<class InputIterator>
constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Preconditions: p is a valid iterator on *this.
// Effects: Equivalent to insert(p - begin(), basic_string(first, last, get_allocator())). Returns: An iterator which refers to the first inserted character, or p if first == last.
template<container-compatible-range<charT> R>
constexpr iterator insert_range(const_iterator p, R&& rg);
// Preconditions: p is a valid iterator on *this.
// Effects: Equivalent to insert(p - begin(), basic_string(from_range, std::forward<R>(rg), get_allocator())).
// Returns: An iterator which refers to the first inserted character, or p if rg is empty.
constexpr iterator insert(const_iterator p, initializer_list<charT> il);
// Effects: Equivalent to: return insert(p, il.begin(), il.end());
// 23.4.3.7.5 basic_string::erase
constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
// Effects: Determines the effective length xlen of the string to be removed as the smaller of n and size() - pos. Removes the characters in the range [begin() + pos, begin() + pos + xlen).
// Returns: *this.
// Throws: out_of_range if pos > size().
constexpr iterator erase(const_iterator p);
// Preconditions: p is a valid dereferenceable iterator on *this. Effects: Removes the character referred to by p.
// Returns: An iterator which points to the element immediately following p prior to the element being erased. If no such element exists, end() is returned.
// Throws: Nothing.
constexpr iterator erase(const_iterator first, const_iterator last);
// Preconditions: first and last are valid iterators on *this. [first, last) is a valid range. Effects: Removes the characters in the range [first, last).
// Returns: An iterator which points to the element pointed to by last prior to the other elements being erased. If no such element exists, end() is returned.
// Throws: Nothing.
constexpr void pop_back();
// Preconditions: !empty().
// Effects: Equivalent to erase(end() - 1).
// Throws: Nothing.
// 23.4.3.7.6 basic_string::replace [string.replace]
constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
// Effects: Equivalent to:
return replace(pos1, n1, str.data(), str.size());
constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
size_type pos2, size_type n2 = npos);
// Effects: Equivalent to:
return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
template<class T>
constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: basic_string_view<charT, traits> sv = t;
return replace(pos1, n1, sv.data(), sv.size());
template<class T>
constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
size_type pos2, size_type n2 = npos);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return replace(pos1, n1, sv.substr(pos2, n2));
constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
// Preconditions: [s, s + n2) is a valid range.
// Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error. Otherwise, the function replaces the characters in the range [begin() + pos1, begin() + pos1 + xlen) with a copy of the range [s, s + n2). Returns: *this. Throws:
// — out_of_range if pos1 > size(),
// — length_error if the length of the resulting string would exceed max_size(), or — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
// Effects: Equivalent to: return replace(pos, n, s, traits::length(s)); constexpr basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);
// Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error. Otherwise, the function replaces the characters in the range [begin() + pos1, begin() + pos1 + xlen) with n2 copies of c.
// Returns: *this. Throws:
// — out_of_range if pos1 > size(),
// — length_error if the length of the resulting string would exceedmax_size(), or — any exceptions thrown by allocator_traits<Allocator>::allocate.
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
// Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(str)); template<class T>
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Preconditions: [begin(), i1) and [i1, i2) are valid ranges.
// Effects: Equivalent to:
basic_string_view<charT, traits> sv = t;
return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
// Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(s, n)); constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);
// Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(s));
constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
// Preconditions: [begin(), i1) and [i1, i2) are valid ranges.
// Effects: Equivalent to: return replace(i1 - begin(), i2 - i1, n, c);
template<class InputIterator>
constexpr basic_string& replace(const_iterator i1, const_iterator i2,
InputIterator j1, InputIterator j2);
// Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
// Effects: Equivalent to: return replace(i1, i2, basic_string(j1, j2, get_allocator()));
template<container-compatible-range<charT> R>
constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
// Effects: Equivalent to:
return replace(i1, i2, basic_string(from_range, std::forward<R>(rg), get_allocator()));
constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
// Effects: Equivalent to: return replace(i1, i2, il.begin(), il.size());
// 23.4.3.7.7 basic_string::copy [string.copy]
constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(*this).copy(s, n, pos);
// [Note 1: This does not terminate s with a null object.
// 23.4.3.7.8 basic_string::swap [string.swap]
constexpr void swap(basic_string& s)
noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
allocator_traits<Allocator>::is_always_equal::value);
// Preconditions: allocator_traits<Allocator>::propagate_on_container_swap::value is true or get_allocator() == s.get_allocator().
// — Each member function of the form
constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
// has effects equivalent to:
return F (basic_string_view<charT, traits>(str), pos);
// — Each member function of the form
constexpr size_type F(const charT* s, size_type pos) const;
// has effects equivalent to:
return F (basic_string_view<charT, traits>(s), pos);
// — Each member function of the form
constexpr size_type F(const charT* s, size_type pos, size_type n) const;
// has effects equivalent to: return F (basic_string_view<charT, traits>(s, n), pos);
// — Each member function of the form
constexpr size_type F(charT c, size_type pos) const noexcept;
has effects equivalent to:
return F(basic_string_view<charT, traits>(addressof(c), 1), pos);
template<class T>
constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
template<class T>
constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see_below);
template<class T>
constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see_below);
template<class T>
constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see_below);
template<class T>
constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see_below);
// Postconditions: *this contains the same sequence of characters that was in s, s contains the same sequence of characters that was in *this.
// Let F be one of find, rfind, find_first_of, find_last_of, find_first_not_of, and find_last_not_of.
// Throws: Nothing. Complexity: Constant time.
// 23.4.3.8 String operations [string.ops]
// 23.4.3.8.1 Accessors [string.accessors]
constexpr const charT* c_str() const noexcept;
constexpr const charT* data() const noexcept;
// Returns: A pointer p such that p + i == addressof(operator[](i)) for each i in [0, size()]. Complexity: Constant time.
// Remarks: The program shall not modify any of the values stored in the character array; otherwise, the behavior is undefined.
constexpr charT* data() noexcept;
// Returns: A pointer p such that p + i == addressof(operator[](i)) for each i in [0, size()]. Complexity: Constant time.
// Remarks: The program shall not modify the value stored at p + size() to any value other than charT(); otherwise, the behavior is undefined.
constexpr operator basic_string_view<charT, traits>() const noexcept;
// Effects: Equivalent to: return basic_string_view<charT, traits>(data(), size()); constexpr allocator_type get_allocator() const noexcept;
// Returns: A copy of the Allocator object used to construct the string or, if that allocator has been replaced, a copy of the most recent replacement.
// 23.4.3.8.2 Searching [string.find]
template<class T>
constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Let G be the name of the function. Equivalent to: basic_string_view<charT, traits> s = *this, sv = t;
return s.G(sv, pos);
// Remarks: The exception specification is equivalent to is_nothrow_convertible_v<const T&, basic_- string_view<charT, traits>>.
// 23.4.3.8.3 basic_string::substr [string.substr]
constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
// Effects: Determines the effective length rlen of the string to copy as the smaller of n and size() - pos.
// Returns: basic_string(data()+pos, rlen). Throws: out_of_range if pos > size().
// 23.4.3.8.4 basic_string::compare template<class T> [string.compare]
constexpr int compare(const T& t) const noexcept(see_below);
// Constraints:— is_convertible_v<const T&, basic_string_view<charT, traits>> is true and
// — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to: return basic_string_view<charT, traits>(*this).compare(t);
// Remarks: The exception specification is equivalent to is_nothrow_convertible_v<const T&, basic_- string_view<charT, traits>>.
template<class T>
constexpr int compare(size_type pos1, size_type n1, const T& t) const;
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
template<class T>
constexpr int compare(size_type pos1, size_type n1, const T& t,
size_type pos2, size_type n2 = npos) const;
// Constraints: — is_convertible_v<const T&, basic_string_view<charT, traits>> is true and — is_convertible_v<const T&, const charT*> is false.
// Effects: Equivalent to:
basic_string_view<charT, traits> s = *this, sv = t;
return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
constexpr int compare(const basic_string& str) const noexcept;
// Effects: Equivalent to: return compare(basic_string_view<charT, traits>(str)); constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
// Effects: Equivalent to: return compare(pos1, n1, basic_string_view<charT, traits>(str));
operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = lhs;
r.append(rhs);
return r;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
const basic_string<charT, traits, Allocator>& rhs);
constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
size_type pos2, size_type n2 = npos) const;
// Effects: Equivalent to:
return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
constexpr int compare(const charT* s) const;
// Effects: Equivalent to: return compare(basic_string_view<charT, traits>(s)); constexpr int compare(size_type pos, size_type n1, const charT* s) const;
// Effects: Equivalent to: return compare(pos, n1, basic_string_view<charT, traits>(s));
constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
// Effects: Equivalent to: return compare(pos, n1, basic_string_view<charT, traits>(s, n2));
// 23.4.3.8.5 basic_string::starts_with [string.starts.with]
constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool starts_with(charT x) const noexcept;
constexpr bool starts_with(const charT* x) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(data(), size()).starts_with(x);
// 23.4.3.8.6 basic_string::ends_with [string.ends.with]
constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
constexpr bool ends_with(charT x) const noexcept;
constexpr bool ends_with(const charT* x) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(data(), size()).ends_with(x);
// 23.4.3.8.7 basic_string::contains [string.contains]
constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
constexpr bool contains(charT x) const noexcept;
constexpr bool contains(const charT* x) const;
// Effects: Equivalent to:
return basic_string_view<charT, traits>(data(), size()).contains(x);
// 23.4.4 Non-member functions [string.nonmembers]
// 23.4.4.1 operator+ [string.op.plus]
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs, const charT* rhs);
// Effects: Equivalent to: lhs.append(rhs);
return std::move(lhs);
operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
// Effects: Equivalent to: rhs.insert(0, lhs);
return std::move(rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs,
basic_string<charT, traits, Allocator>&& rhs);
// Effects: Equivalent to: lhs.append(rhs);
return std::move(lhs);
// except that both lhs and rhs are left in valid but unspecified states.
// [Note 1: If lhs and rhs have equal allocators, the implementation can move from either.
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs,
basic_string<charT, traits, Allocator>&& rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = rhs;
r.insert(0, lhs);
return r;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = rhs;
r.insert(r.begin(), lhs);
return r;
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);
// Effects: Equivalent to: rhs.insert(rhs.begin(), lhs);
return std::move(rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);
// Effects: Equivalent to:
basic_string<charT, traits, Allocator> r = lhs;
r.push_back(rhs);
return r;
constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
// Effects: Let op be the operator. Equivalent to:
return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);
template<class charT, class traits, class Allocator>
constexpr basic_string<charT, traits, Allocator>
operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);
// Effects: Equivalent to: lhs.push_back(rhs);
return std::move(lhs);
// 23.4.4.2 Non-member comparison operator functions [string.special]
template<class charT, class traits, class Allocator>
constexpr bool
operator==(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs);
template<class charT, class traits, class Allocator>
constexpr see_below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
// 23.4.4.3 swap [string.io]
template<class charT, class traits, class Allocator>
constexpr void
swap(basic_string<charT, traits, Allocator>& lhs,
basic_string<charT, traits, Allocator>& rhs)
noexcept(noexcept(lhs.swap(rhs)));
// Effects: Equivalent to lhs.swap(rhs).
// 23.4.4.4 Inserters and extractors [string.cmp]
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
// Effects: Behaves as a formatted input function (31.7.4.3.1). After constructing a sentry object, if the sentry object returns true when converted to a value of type bool, calls str.erase() and then extracts characters from is and appends them to str as if by calling str.append(1, c). If is.width() is greater than zero, the maximum number n of characters appended is is.width(); otherwise n is str.max_size(). Characters are extracted and appended until any of the following occurs:
// — n characters are stored;
// — end-of-file occurs on the input sequence;
// — isspace(c, is.getloc()) is true for the next available input character c.
// After the last character (if any) is extracted, is.width(0) is called and the sentry object is destroyed. If the function extracts no characters, it calls is.setstate(ios_base::failbit), which may throw ios_base::failure (31.5.4.4).
// Returns: is.
template<class charT, class traits, class Allocator>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const basic_string<charT, traits, Allocator>& str);
// Effects: Equivalent to: return os << basic_string_view<charT, traits>(str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
basic_string<charT, traits, Allocator>& str,
charT delim);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
basic_string<charT, traits, Allocator>& str,
charT delim);
// Effects: Behaves as an unformatted input function (31.7.4.4), except that it does not affect the value returned by subsequent calls to basic_istream<>::gcount(). After constructing a sentry object, if the sentry object returns true when converted to a value of type bool, calls str.erase() and then extracts characters from is and appends them to str as if by calling str.append(1, c) until any of the following occurs:
// — end-of-file occurs on the input sequence (in which case, the getline function calls is.setstate( ios_base::eofbit)).
// — traits::eq(c, delim) for the next available input character c (in which case, c is extracted but not appended) (31.5.4.4)
// — str.max_size() characters are stored (in which case, the function calls is.setstate(ios_- base::failbit)) (31.5.4.4)
// The conditions are tested in the order shown. In any case, after the last character is extracted, the sentry object is destroyed. If the function extracts no characters, it calls is.setstate(ios_base::failbit) which may throw ios_base::failure (31.5.4.4).
// Returns: is.
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
basic_string<charT, traits, Allocator>& str);
template<class charT, class traits, class Allocator>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>&& is,
basic_string<charT, traits, Allocator>& str);
// Returns: getline(is, str, is.widen(’\n’)).
// 23.4.4.5 Erasure [string.erasure]
template<class charT, class traits, class Allocator, class U>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase(basic_string<charT, traits, Allocator>& c, const U& value);
// Effects: Equivalent to:
auto it = remove(c.begin(), c.end(), value);
auto r = distance(it, c.end());
c.erase(it, c.end());
return r;
template<class charT, class traits, class Allocator, class Predicate>
constexpr typename basic_string<charT, traits, Allocator>::size_type
erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
// Effects: Equivalent to:
auto it = remove_if(c.begin(), c.end(), pred);
auto r = distance(it, c.end());
c.erase(it, c.end());
return r;
// Returns: Each function returns a string object holding the character representation of the value of its argument that would be generated by calling sprintf(buf, fmt, val) with a format specifier of "%d", "%u", "%ld", "%lu", "%lld", "%llu", "%f", "%f", or "%Lf", respectively, where buf designates an internal character buffer of sufficient size.
// 23.4.5 Numeric conversions [string.conversions]
int stoi(const string& str, size_t* idx = nullptr, int base = 10);
long stol(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
// Effects: The first two functions call strtol(str.c_str(), ptr, base), and the last three functions call strtoul(str.c_str(), ptr, base), strtoll(str.c_str(), ptr, base), and strtoull(str.c_- str(), ptr, base), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if strtol, strtoul, strtoll, or strtoull reports that no conversion can be performed. Throws out_of_range if strtol, strtoul, strtoll or strtoull sets errno to ERANGE, or if the converted value is outside the range of representable values for the return type.
float stof(const string& str, size_t* idx = nullptr);
double stod(const string& str, size_t* idx = nullptr);
long double stold(const string& str, size_t* idx = nullptr);
// Effects: These functions call strtof(str.c_str(), ptr), strtod(str.c_str(), ptr), and strtold( str.c_str(), ptr), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if strtof, strtod, or strtold reports that no conversion can be performed. Throws out_of_range if strtof, strtod, or strtold sets errno to ERANGE or if the converted value is outside the range of representable values for the return type.
string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);
int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
// Effects: The first two functions call wcstol(str.c_str(), ptr, base), and the last three functions call wcstoul(str.c_str(), ptr, base), wcstoll(str.c_str(), ptr, base), and wcstoull(str.c_- str(), ptr, base), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if wcstol, wcstoul, wcstoll, or wcstoull reports that no conversion can be performed. Throws out_of_range if the converted value is outside the range of representable values for the return type.
// Returns: Each function returns a wstring object holding the character representation of the value of its argument that would be generated by calling swprintf(buf, buffsz, fmt, val) with a format specifier of L"%d", L"%u", L"%ld", L"%lu", L"%lld", L"%llu", L"%f", L"%f", or L"%Lf", respectively, where buf designates an internal character buffer of sufficient size buffsz.
// If S is one of these string types, SV is the corresponding string view type, and s is an object of type S, then hash<S>()(s) == hash<SV>()(SV(s)).
float stof(const wstring& str, size_t* idx = nullptr);
double stod(const wstring& str, size_t* idx = nullptr);
long double stold(const wstring& str, size_t* idx = nullptr);
// Effects: These functions call wcstof(str.c_str(), ptr), wcstod(str.c_str(), ptr), and wcstold( str.c_str(), ptr), respectively. Each function returns the converted result, if any. The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx. If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.
// Returns: The converted result.
// Throws: invalid_argument if wcstof, wcstod, or wcstold reports that no conversion can be performed.
// Throws out_of_range if wcstof, wcstod, or wcstold sets errno to ERANGE.
wstring to_wstring(int val);
wstring to_wstring(unsigned val);
wstring to_wstring(long val);
wstring to_wstring(unsigned long val);
wstring to_wstring(long long val);
wstring to_wstring(unsigned long long val);
wstring to_wstring(float val);
wstring to_wstring(double val);
wstring to_wstring(long double val);
// 23.4.6 Hash support [basic.string.hash]
template<> struct hash<string>;
template<> struct hash<u8string>;
template<> struct hash<u16string>;
template<> struct hash<u32string>;
template<> struct hash<wstring>;
template<> struct hash<pmr::string>;
template<> struct hash<pmr::u8string>;
template<> struct hash<pmr::u16string>;
template<> struct hash<pmr::u32string>;
template<> struct hash<pmr::wstring>;
// 23.4.7 Suffix for basic_string literals [basic.string.literals]
constexpr string operator""s(const char* str, size_t len);
// Returns: string{str, len}.
constexpr u8string operator""s(const char8_t* str, size_t len);
// Returns: u8string{str, len}.
constexpr u16string operator""s(const char16_t* str, size_t len);
// Returns: u16string{str, len}.
constexpr u32string operator""s(const char32_t* str, size_t len);
// Returns: u32string{str, len}.
constexpr wstring operator""s(const wchar_t* str, size_t len);
// Returns: wstring{str, len}.
// [Note 1: The same suffix s is used for chrono::duration literals denoting seconds but there is no conflict, since duration suffixes apply to numbers and string literal suffixes apply to character array literals.
int main() {
cout << n4910 << endl;
return EXIT_SUCCESS;
}
編纂・実行結果(compile and go)
bash
$ clang++ p808.cpp -std=03 -o p808l -I. -Wall
In file included from p808.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 \
^
p808.cpp:19:110: error: use of undeclared identifier 'char8_t'; did you mean 'wchar_t'?
template<class charT> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
^~~~~~~
wchar_t
p808.cpp:19:150: error: use of undeclared identifier 'char16_t'
template<class charT> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
^
p808.cpp:19:191: error: use of undeclared identifier 'char32_t'
template<class charT> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
^
p808.cpp:21:91: error: a space is required between consecutive right angle brackets (use '> >')
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
^~
> >
p808.cpp:24:7: error: unknown type name 'constexpr'
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:24:17: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:24:17: error: no variable template matches partial specialization
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:24:55: error: expected ';' at end of declaration
constexpr basic_string<charT, traits, Allocator>
^
;
p808.cpp:25:25: error: reference to 'basic_string' is ambiguous
operator+(const basic_string<charT, traits, Allocator>& lhs,
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:25:38: error: use of undeclared identifier 'charT'; did you mean 'char'?
operator+(const basic_string<charT, traits, Allocator>& lhs,
^~~~~
char
p808.cpp:25:45: error: use of undeclared identifier 'traits'
operator+(const basic_string<charT, traits, Allocator>& lhs,
^
p808.cpp:26:25: error: reference to 'basic_string' is ambiguous
const basic_string<charT, traits, Allocator>& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:26:38: error: use of undeclared identifier 'charT'; did you mean 'char'?
const basic_string<charT, traits, Allocator>& rhs);
^~~~~
char
p808.cpp:26:45: error: use of undeclared identifier 'traits'
const basic_string<charT, traits, Allocator>& rhs);
^
p808.cpp:25:9: error: C++ requires a type specifier for all declarations
operator+(const basic_string<charT, traits, Allocator>& lhs,
^
p808.cpp:28:7: error: unknown type name 'constexpr'
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:28:17: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:28:17: error: no variable template matches partial specialization
constexpr basic_string<charT, traits, Allocator>
^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.
$ clang++ p808.cpp -std=2b -o p808l -I. -Wall
p808.cpp:24:17: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:25:25: error: reference to 'basic_string' is ambiguous
operator+(const basic_string<charT, traits, Allocator>& lhs,
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:26:25: error: reference to 'basic_string' is ambiguous
const basic_string<charT, traits, Allocator>& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:28:17: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:29:19: error: reference to 'basic_string' is ambiguous
operator+(basic_string<charT, traits, Allocator>&& lhs,
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:30:25: error: reference to 'basic_string' is ambiguous
const basic_string<charT, traits, Allocator>& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:32:17: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:33:25: error: reference to 'basic_string' is ambiguous
operator+(const basic_string<charT, traits, Allocator>& lhs,
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:34:19: error: reference to 'basic_string' is ambiguous
basic_string<charT, traits, Allocator>&& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:36:13: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:37:15: error: reference to 'basic_string' is ambiguous
operator+(basic_string<charT, traits, Allocator>&& lhs,
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:38:15: error: reference to 'basic_string' is ambiguous
basic_string<charT, traits, Allocator>&& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:40:13: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:42:21: error: reference to 'basic_string' is ambiguous
const basic_string<charT, traits, Allocator>& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:44:13: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:46:15: error: reference to 'basic_string' is ambiguous
basic_string<charT, traits, Allocator>&& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:48:13: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:50:21: error: reference to 'basic_string' is ambiguous
const basic_string<charT, traits, Allocator>& rhs);
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
p808.cpp:52:13: error: reference to 'basic_string' is ambiguous
constexpr basic_string<charT, traits, Allocator>
^
p808.cpp:22:13: note: candidate found by name lookup is 'std::basic_string'
class basic_string;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/basic_string.h:77:11: note: candidate found by name lookup is 'std::__cxx11::basic_string'
class basic_string
^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.
$ g++ p808.cpp -std=03 -o p808g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
from N4910.h:11,
from p808.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 \
| ^~~~~
p808.cpp:24:7: warning: identifier 'constexpr' is a keyword in C++11 [-Wc++11-compat]
24 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:74:67: warning: identifier 'noexcept' is a keyword in C++11 [-Wc++11-compat]
74 | const basic_string<charT, traits, Allocator>& rhs) noexcept;
| ^~~~~~~~
p808.cpp:126:43: warning: identifier 'nullptr' is a keyword in C++11 [-Wc++11-compat]
126 | int stoi(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:660:75: error: too many decimal points in number
660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
| ^~~~~~~~
p808.cpp:19:110: error: 'char8_t' was not declared in this scope; did you mean 'wchar_t'?
19 | T> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
| ^~~~~~~
| wchar_t
p808.cpp:19:117: error: template argument 1 is invalid
19 | ct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
| ^
p808.cpp:19:150: error: 'char16_t' was not declared in this scope
19 | char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
| ^~~~~~~~
p808.cpp:19:158: error: template argument 1 is invalid
19 | aits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
| ^
p808.cpp:19:191: error: 'char32_t' was not declared in this scope
19 | r_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
| ^~~~~~~~
p808.cpp:19:199: error: template argument 1 is invalid
19 | <char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;
| ^
p808.cpp:21:91: error: spurious '>>', use '>' to terminate a template argument list
21 | template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
| ^~
p808.cpp:22:13: error: template argument required for 'class basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:21:76: error: two or more data types in declaration of 'type name'
21 | template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
| ^~~~~~~~~~~~~~~~~
p808.cpp:22:25: error: expected '>' before ';' token
22 | class basic_string;
| ^
p808.cpp:22:25: error: expected unqualified-id before ';' token
p808.cpp:24:7: error: 'constexpr' does not name a type
24 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:24:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:28:7: error: 'constexpr' does not name a type
28 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:28:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:32:7: error: 'constexpr' does not name a type
32 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:32:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:36:3: error: 'constexpr' does not name a type
36 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:36:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:40:3: error: 'constexpr' does not name a type
40 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:40:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:44:3: error: 'constexpr' does not name a type
44 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:44:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:48:3: error: 'constexpr' does not name a type
48 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:48:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:52:3: error: 'constexpr' does not name a type
52 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:52:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:56:3: error: 'constexpr' does not name a type
56 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:56:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:60:3: error: 'constexpr' does not name a type
60 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:60:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:64:3: error: 'constexpr' does not name a type
64 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:64:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:68:3: error: 'constexpr' does not name a type
68 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:68:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:72:3: error: 'constexpr' does not name a type
72 | constexpr bool
| ^~~~~~~~~
p808.cpp:72:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:76:3: error: 'constexpr' does not name a type
76 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~
p808.cpp:76:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:79:1: error: 'constexpr' does not name a type
79 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~
p808.cpp:79:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:82:1: error: 'constexpr' does not name a type
82 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
p808.cpp:82:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:85:3: error: 'constexpr' does not name a type
85 | constexpr void
| ^~~~~~~~~
p808.cpp:85:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:105:41: error: expected ',' or '...' before '&&' token
105 | getline(basic_istream<charT, traits>&& is,
| ^~
p808.cpp:114:41: error: expected ',' or '...' before '&&' token
114 | getline(basic_istream<charT, traits>&& is,
| ^~
p808.cpp:118:3: error: 'constexpr' does not name a type
118 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~
p808.cpp:118:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:121:3: error: 'constexpr' does not name a type
121 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~
p808.cpp:121:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:124:7: error: expected nested-name-specifier before 'string'
124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~
p808.cpp:124:42: error: expected nested-name-specifier before 'u8string'
124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~~
p808.cpp:124:82: error: expected nested-name-specifier before 'u16string'
124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~~~
p808.cpp:124:124: error: expected nested-name-specifier before 'u32string'
124 | ; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~~~
p808.cpp:124:166: error: expected nested-name-specifier before 'wstring'
124 | using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~
p808.cpp:126:43: error: 'nullptr' was not declared in this scope
126 | int stoi(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:127:44: error: 'nullptr' was not declared in this scope
127 | long stol(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:128:54: error: 'nullptr' was not declared in this scope
128 | unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:129:50: error: 'nullptr' was not declared in this scope
129 | long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:130:60: error: 'nullptr' was not declared in this scope
130 | unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10); float stof(const string& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:130:129: error: 'nullptr' was not declared in this scope
130 | ng& str, size_t* idx = nullptr, int base = 10); float stof(const string& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:131:46: error: 'nullptr' was not declared in this scope
131 | double stod(const string& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:132:52: error: 'nullptr' was not declared in this scope
132 | long double stold(const string& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:142:44: error: 'nullptr' was not declared in this scope
142 | int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:143:45: error: 'nullptr' was not declared in this scope
143 | long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:144:55: error: 'nullptr' was not declared in this scope
144 | unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:145:51: error: 'nullptr' was not declared in this scope
145 | long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:146:61: error: 'nullptr' was not declared in this scope
146 | unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:147:46: error: 'nullptr' was not declared in this scope
147 | float stof(const wstring& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:148:47: error: 'nullptr' was not declared in this scope
148 | double stod(const wstring& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:149:55: error: 'nullptr' was not declared in this scope
149 | long double stold(const wstring& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:160:59: error: spurious '>>', use '>' to terminate a template argument list
160 | template<class charT, class traits = char_traits<charT>>
| ^~
p808.cpp:161:7: error: expected '>' before 'using'
161 | using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
| ^~~~~
p808.cpp:161:90: error: expected unqualified-id before ';' token
161 | using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
| ^
p808.cpp:162:11: error: expected nested-name-specifier before 'string'
162 | using string = basic_string<char>;
| ^~~~~~
p808.cpp:163:11: error: expected nested-name-specifier before 'u8string'
163 | using u8string = basic_string<char8_t>;
| ^~~~~~~~
p808.cpp:164:11: error: expected nested-name-specifier before 'u16string'
164 | using u16string = basic_string<char16_t>;
| ^~~~~~~~~
p808.cpp:165:11: error: expected nested-name-specifier before 'u32string'
165 | using u32string = basic_string<char32_t>;
| ^~~~~~~~~
p808.cpp:166:11: error: expected nested-name-specifier before 'wstring'
166 | using wstring = basic_string<wchar_t>;
| ^~~~~~~
p808.cpp:169:87: error: 'u8string' was not declared in this scope
169 | template<class T> struct hash; template<> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~~
p808.cpp:169:87: note: 'std::u8string' is only available from C++20 onwards
p808.cpp:169:95: error: template argument 1 is invalid
169 | late<class T> struct hash; template<> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:169:121: error: 'u16string' was not declared in this scope
169 | template<> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~~~
p808.cpp:169:121: note: 'std::u16string' is only available from C++11 onwards
p808.cpp:169:130: error: template argument 1 is invalid
169 | <> struct hash<string>; template<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:169:156: error: 'u32string' was not declared in this scope
169 | mplate<> struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~~~
p808.cpp:169:156: note: 'std::u32string' is only available from C++11 onwards
p808.cpp:169:165: error: template argument 1 is invalid
169 | struct hash<u8string>; template<> struct hash<u16string>; template<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:169:229: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
169 | te<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~
In file included from /usr/local/include/c++/12.1.0/iosfwd:39,
from /usr/local/include/c++/12.1.0/ios:38,
from /usr/local/include/c++/12.1.0/ostream:38,
from /usr/local/include/c++/12.1.0/iostream:39,
from N4910.h:2:
/usr/local/include/c++/12.1.0/bits/stringfwd.h:77:33: note: 'std::string' declared here
77 | typedef basic_string<char> string;
| ^~~~~~
p808.cpp:169:229: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
169 | te<> struct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:77:33: note: 'std::string' declared here
77 | typedef basic_string<char> string;
| ^~~~~~
p808.cpp:169:235: error: template argument 1 is invalid
169 | truct hash<u32string>; template<> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:169:266: error: 'u8string' is not a member of 'std::pmr'
169 | <> struct hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~~
p808.cpp:169:266: error: 'u8string' is not a member of 'std::pmr'
p808.cpp:169:274: error: template argument 1 is invalid
169 | t hash<wstring>; template<> struct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:169:305: error: 'u16string' is not a member of 'std::pmr'
169 | uct hash<pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~~~
p808.cpp:169:305: error: 'u16string' is not a member of 'std::pmr'
p808.cpp:169:314: error: template argument 1 is invalid
169 | pmr::string>; template<> struct hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:169:345: error: 'u32string' is not a member of 'std::pmr'
169 | hash<pmr::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~~~
p808.cpp:169:345: error: 'u32string' is not a member of 'std::pmr'
p808.cpp:169:354: error: template argument 1 is invalid
169 | ::u8string>; template<> struct hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:169:385: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
169 | t hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
80 | typedef basic_string<wchar_t> wstring;
| ^~~~~~~
p808.cpp:169:385: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
169 | t hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
80 | typedef basic_string<wchar_t> wstring;
| ^~~~~~~
p808.cpp:169:392: error: template argument 1 is invalid
169 | t hash<pmr::u16string>; template<> struct hash<pmr::u32string>; template<> struct hash<pmr::wstring>;
| ^
p808.cpp:173:1: error: 'constexpr' does not name a type
173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:173:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:60: error: 'constexpr' does not name a type
173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:173:60: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:124: error: 'constexpr' does not name a type
173 | t char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:173:124: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:190: error: 'constexpr' does not name a type
173 | r8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:173:190: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:173:256: error: 'constexpr' does not name a type
173 | 16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:173:256: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:183:50: error: spurious '>>', use '>' to terminate a template argument list
183 | class Allocator = allocator<charT>>
| ^~
p808.cpp:184:27: error: definition of 'class std::basic_string' inside template parameter list
184 | class basic_string {
| ^
p808.cpp:183:35: error: two or more data types in declaration of 'type name'
183 | class Allocator = allocator<charT>>
| ^~~~~~~~~~~~~~~~~
p808.cpp:401:3: error: expected '>' before 'template'
401 | template<class T>
| ^~~~~~~~
p808.cpp:403:69: error: expected unqualified-id before ';' token
403 | size_type pos2, size_type n2 = npos) const;
| ^
p808.cpp:404:3: error: 'constexpr' does not name a type
404 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~~~
p808.cpp:404:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:405:3: error: 'constexpr' does not name a type
405 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
| ^~~~~~~~~
p808.cpp:405:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:406:3: error: 'constexpr' does not name a type
406 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
p808.cpp:406:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:408:3: error: 'constexpr' does not name a type
408 | constexpr int compare(const charT* s) const;
| ^~~~~~~~~
p808.cpp:408:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:409:3: error: 'constexpr' does not name a type
409 | constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
| ^~~~~~~~~
p808.cpp:409:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:410:3: error: 'constexpr' does not name a type
410 | constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
p808.cpp:410:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:411:3: error: 'constexpr' does not name a type
411 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:411:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:412:3: error: 'constexpr' does not name a type
412 | constexpr bool starts_with(charT x) const noexcept;
| ^~~~~~~~~
p808.cpp:412:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:413:3: error: 'constexpr' does not name a type
413 | constexpr bool starts_with(const charT* x) const;
| ^~~~~~~~~
p808.cpp:413:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:414:3: error: 'constexpr' does not name a type
414 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:414:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:415:3: error: 'constexpr' does not name a type
415 | constexpr bool ends_with(charT x) const noexcept;
| ^~~~~~~~~
p808.cpp:415:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:416:3: error: 'constexpr' does not name a type
416 | constexpr bool ends_with(const charT* x) const;
| ^~~~~~~~~
p808.cpp:416:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:417:3: error: 'constexpr' does not name a type
417 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:417:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:418:3: error: 'constexpr' does not name a type
418 | constexpr bool contains(charT x) const noexcept;
| ^~~~~~~~~
p808.cpp:418:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:419:3: error: 'constexpr' does not name a type
419 | constexpr bool contains(const charT* x) const;
| ^~~~~~~~~
p808.cpp:419:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:422:89: error: spurious '>>', use '>' to terminate a template argument list
422 | class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
| ^~
p808.cpp:423:3: error: expected '>' before 'basic_string'
423 | basic_string(InputIterator, InputIterator, Allocator = Allocator())
| ^~~~~~~~~~~~
p808.cpp:426:31: error: expected unqualified-id before ';' token
426 | Allocator>;
| ^
p808.cpp:427:10: error: 'ranges' has not been declared
427 | template<ranges::input_range R,
| ^~~~~~
p808.cpp:427:30: error: expected '>' before 'R'
427 | template<ranges::input_range R,
| ^
p808.cpp:431:11: error: expected unqualified-id before ';' token
431 | Allocator>;
| ^
p808.cpp:434:43: error: spurious '>>', use '>' to terminate a template argument list
434 | class Allocator = allocator<charT>>
| ^~
p808.cpp:435:3: error: expected '>' before 'explicit'
435 | explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
| ^~~~~~~~
p808.cpp:436:46: error: expected unqualified-id before ';' token
436 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:439:43: error: spurious '>>', use '>' to terminate a template argument list
439 | class Allocator = allocator<charT>>
| ^~
p808.cpp:440:3: error: expected '>' before 'basic_string'
440 | basic_string(basic_string_view<charT, traits>,
| ^~~~~~~~~~~~
p808.cpp:443:42: error: expected unqualified-id before ';' token
443 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:456:1: error: 'constexpr' does not name a type
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~
p808.cpp:456:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:458:1: error: 'constexpr' does not name a type
458 | constexpr basic_string(basic_string&& str) noexcept;
| ^~~~~~~~~
p808.cpp:458:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:460:1: error: 'constexpr' does not name a type
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~
p808.cpp:460:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:462:1: error: 'constexpr' does not name a type
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~
p808.cpp:462:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:466:3: error: 'constexpr' does not name a type
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:466:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:468:15: error: expected constructor, destructor, or type conversion before '(' token
468 | basic_string(sv.substr(pos, n), a);
| ^
p808.cpp:470:3: error: 'constexpr' does not name a type
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:470:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:474:1: error: 'constexpr' does not name a type
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:474:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:478:1: error: 'constexpr' does not name a type
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:478:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:482:1: error: 'constexpr' does not name a type
482 | constexpr basic_string& operator=(const basic_string& str);
| ^~~~~~~~~
p808.cpp:482:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:483:1: error: 'constexpr' does not name a type
483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:483:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:487:3: error: 'constexpr' does not name a type
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:487:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:490:10: error: 'container' has not been declared
490 | template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:490:19: error: expected '>' before '-' token
490 | template<container-compatible-range<charT> R>
| ^
p808.cpp:491:1: error: 'constexpr' does not name a type
491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
| ^~~~~~~~~
p808.cpp:491:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:494:1: error: 'constexpr' does not name a type
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~
p808.cpp:494:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:495:1: error: 'constexpr' does not name a type
495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
| ^~~~~~~~~
p808.cpp:495:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:499:89: error: spurious '>>', use '>' to terminate a template argument list
499 | class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
| ^~
p808.cpp:500:1: error: expected '>' before 'basic_string'
500 | basic_string(InputIterator, InputIterator, Allocator = Allocator())
| ^~~~~~~~~~~~
p808.cpp:503:29: error: expected unqualified-id before ';' token
503 | Allocator>;
| ^
p808.cpp:507:43: error: spurious '>>', use '>' to terminate a template argument list
507 | class Allocator = allocator<charT>>
| ^~
p808.cpp:508:3: error: expected '>' before 'explicit'
508 | explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
| ^~~~~~~~
p808.cpp:509:46: error: expected unqualified-id before ';' token
509 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:512:43: error: spurious '>>', use '>' to terminate a template argument list
512 | class Allocator = allocator<charT>>
| ^~
p808.cpp:513:3: error: expected '>' before 'basic_string'
513 | basic_string(basic_string_view<charT, traits>,
| ^~~~~~~~~~~~
p808.cpp:516:46: error: expected unqualified-id before ';' token
516 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:519:1: error: 'constexpr' does not name a type
519 | constexpr basic_string& operator=(basic_string&& str)
| ^~~~~~~~~
p808.cpp:519:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:524:1: error: 'constexpr' does not name a type
524 | constexpr basic_string& operator=(const T& t);
| ^~~~~~~~~
p808.cpp:524:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:528:8: error: expected unqualified-id before 'return'
528 | return assign(sv);
| ^~~~~~
p808.cpp:529:1: error: 'constexpr' does not name a type
529 | constexpr basic_string& operator=(const charT* s);
| ^~~~~~~~~
p808.cpp:529:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:531:1: error: 'constexpr' does not name a type
531 | constexpr basic_string& operator=(charT c);
| ^~~~~~~~~
p808.cpp:531:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:533:1: error: expected unqualified-id before 'return'
533 | return *this = basic_string_view<charT, traits>(addressof(c), 1);
| ^~~~~~
p808.cpp:534:1: error: 'constexpr' does not name a type
534 | constexpr basic_string& operator=(initializer_list<charT> il);
| ^~~~~~~~~
p808.cpp:534:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:536:1: error: expected unqualified-id before 'return'
536 | return *this = basic_string_view<charT, traits>(il.begin(), il.size());
| ^~~~~~
p808.cpp:538:1: error: 'constexpr' does not name a type
538 | constexpr iterator begin() noexcept;
| ^~~~~~~~~
p808.cpp:538:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:539:1: error: 'constexpr' does not name a type
539 | constexpr const_iterator begin() const noexcept;
| ^~~~~~~~~
p808.cpp:539:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:540:1: error: 'constexpr' does not name a type
540 | constexpr const_iterator cbegin() const noexcept;
| ^~~~~~~~~
p808.cpp:540:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:542:1: error: 'constexpr' does not name a type
542 | constexpr iterator end() noexcept;
| ^~~~~~~~~
p808.cpp:542:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:543:1: error: 'constexpr' does not name a type
543 | constexpr const_iterator end() const noexcept;
| ^~~~~~~~~
p808.cpp:543:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:544:1: error: 'constexpr' does not name a type
544 | constexpr const_iterator cend() const noexcept;
| ^~~~~~~~~
p808.cpp:544:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:546:1: error: 'constexpr' does not name a type
546 | constexpr reverse_iterator rbegin() noexcept;
| ^~~~~~~~~
p808.cpp:546:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:547:1: error: 'constexpr' does not name a type
547 | constexpr const_reverse_iterator rbegin() const noexcept;
| ^~~~~~~~~
p808.cpp:547:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:548:1: error: 'constexpr' does not name a type
548 | constexpr const_reverse_iterator crbegin() const noexcept;
| ^~~~~~~~~
p808.cpp:548:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:550:1: error: 'constexpr' does not name a type
550 | constexpr reverse_iterator rend() noexcept;
| ^~~~~~~~~
p808.cpp:550:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:551:1: error: 'constexpr' does not name a type
551 | constexpr const_reverse_iterator rend() const noexcept;
| ^~~~~~~~~
p808.cpp:551:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:552:1: error: 'constexpr' does not name a type
552 | constexpr const_reverse_iterator crend() const noexcept;
| ^~~~~~~~~
p808.cpp:552:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:555:1: error: 'constexpr' does not name a type
555 | constexpr size_type size() const noexcept;
| ^~~~~~~~~
p808.cpp:555:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:556:1: error: 'constexpr' does not name a type
556 | constexpr size_type length() const noexcept;
| ^~~~~~~~~
p808.cpp:556:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:558:6: error: 'constexpr' does not name a type
558 | constexpr size_type max_size() const noexcept;
| ^~~~~~~~~
p808.cpp:558:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:560:1: error: 'constexpr' does not name a type
560 | constexpr void resize(size_type n, charT c);
| ^~~~~~~~~
p808.cpp:560:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:563:1: error: 'constexpr' does not name a type
563 | constexpr void resize(size_type n);
| ^~~~~~~~~
p808.cpp:563:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:565:27: error: 'constexpr' does not name a type
565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
| ^~~~~~~~~
p808.cpp:565:27: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:578:1: error: 'constexpr' does not name a type
578 | constexpr size_type capacity() const noexcept;
| ^~~~~~~~~
p808.cpp:578:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:580:1: error: 'constexpr' does not name a type
580 | constexpr void reserve(size_type res_arg);
| ^~~~~~~~~
p808.cpp:580:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:583:1: error: 'constexpr' does not name a type
583 | constexpr void shrink_to_fit();
| ^~~~~~~~~
p808.cpp:583:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:591:1: error: expected unqualified-id before '[' token
591 | [[nodiscard]] constexpr bool empty() const noexcept;
| ^
p808.cpp:594:1: error: 'constexpr' does not name a type
594 | constexpr const_reference operator[](size_type pos) const;
| ^~~~~~~~~
p808.cpp:594:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:595:1: error: 'constexpr' does not name a type
595 | constexpr reference operator[](size_type pos);
| ^~~~~~~~~
p808.cpp:595:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:599:1: error: 'constexpr' does not name a type
599 | constexpr const_reference at(size_type pos) const;
| ^~~~~~~~~
p808.cpp:599:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:600:1: error: 'constexpr' does not name a type
600 | constexpr reference at(size_type pos);
| ^~~~~~~~~
p808.cpp:600:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:603:1: error: 'constexpr' does not name a type
603 | constexpr const charT& front() const;
| ^~~~~~~~~
p808.cpp:603:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:604:1: error: 'constexpr' does not name a type
604 | constexpr charT& front();
| ^~~~~~~~~
p808.cpp:604:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:607:1: error: 'constexpr' does not name a type
607 | constexpr const charT& back() const;
| ^~~~~~~~~
p808.cpp:607:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:608:1: error: 'constexpr' does not name a type
608 | constexpr charT& back();
| ^~~~~~~~~
p808.cpp:608:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:613:1: error: 'constexpr' does not name a type
613 | constexpr basic_string& operator+=(const basic_string& str);
| ^~~~~~~~~
p808.cpp:613:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:615:1: error: expected unqualified-id before 'return'
615 | return append(str);
| ^~~~~~
p808.cpp:617:1: error: 'constexpr' does not name a type
617 | constexpr basic_string& operator+=(const T& t);
| ^~~~~~~~~
p808.cpp:617:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:620:1: error: 'basic_string_view' does not name a type
620 | basic_string_view<charT, traits> sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:621:8: error: expected unqualified-id before 'return'
621 | return append(sv);
| ^~~~~~
p808.cpp:622:1: error: 'constexpr' does not name a type
622 | constexpr basic_string& operator+=(const charT* s);
| ^~~~~~~~~
p808.cpp:622:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:624:1: error: expected unqualified-id before 'return'
624 | return append(s); constexpr basic_string& operator+=(charT c);
| ^~~~~~
p808.cpp:624:19: error: 'constexpr' does not name a type
624 | return append(s); constexpr basic_string& operator+=(charT c);
| ^~~~~~~~~
p808.cpp:624:19: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:626:1: error: expected unqualified-id before 'return'
626 | return append(size_type{1}, c);
| ^~~~~~
p808.cpp:626:27: error: expected unqualified-id before ',' token
626 | return append(size_type{1}, c);
| ^
p808.cpp:626:30: error: expected constructor, destructor, or type conversion before ')' token
626 | return append(size_type{1}, c);
| ^
p808.cpp:627:1: error: 'constexpr' does not name a type
627 | constexpr basic_string& operator+=(initializer_list<charT> il);
| ^~~~~~~~~
p808.cpp:627:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:630:1: error: 'constexpr' does not name a type
630 | constexpr basic_string& append(const basic_string& str);
| ^~~~~~~~~
p808.cpp:630:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:632:1: error: expected unqualified-id before 'return'
632 | return append(str.data(), str.size());
| ^~~~~~
p808.cpp:633:1: error: 'constexpr' does not name a type
633 | constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
| ^~~~~~~~~
p808.cpp:633:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:635:1: error: expected unqualified-id before 'return'
635 | return append(basic_string_view<charT, traits>(str).substr(pos, n));
| ^~~~~~
p808.cpp:637:3: error: 'constexpr' does not name a type
637 | constexpr basic_string& append(const T& t);
| ^~~~~~~~~
p808.cpp:637:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:641:1: error: 'basic_string_view' does not name a type
641 | basic_string_view<charT, traits> sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:642:3: error: expected unqualified-id before 'return'
642 | return append(sv.data(), sv.size());
| ^~~~~~
p808.cpp:644:3: error: 'constexpr' does not name a type
644 | constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
| ^~~~~~~~~
p808.cpp:644:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:648:1: error: 'basic_string_view' does not name a type
648 | basic_string_view<charT, traits> sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:649:3: error: expected unqualified-id before 'return'
649 | return append(sv.substr(pos, n));
| ^~~~~~
p808.cpp:650:1: error: 'constexpr' does not name a type
650 | constexpr basic_string& append(const charT* s, size_type n);
| ^~~~~~~~~
p808.cpp:650:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:653:1: error: 'constexpr' does not name a type
653 | constexpr basic_string& append(const charT* s);
| ^~~~~~~~~
p808.cpp:653:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:655:1: error: expected unqualified-id before 'return'
655 | return append(s, traits::length(s));
| ^~~~~~
p808.cpp:656:1: error: 'constexpr' does not name a type
656 | constexpr basic_string& append(size_type n, charT c);
| ^~~~~~~~~
p808.cpp:656:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:659:3: error: 'constexpr' does not name a type
659 | constexpr basic_string& append(InputIterator first, InputIterator last);
| ^~~~~~~~~
p808.cpp:659:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:660:12: error: found ':' in nested-name-specifier, expected '::'
660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
| ^
| ::
p808.cpp:660:1: error: 'Constraints' does not name a type
660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
| ^~~~~~~~~~~
p808.cpp:663:10: error: 'container' has not been declared
663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
| ^~~~~~~~~
p808.cpp:663:19: error: expected '>' before '-' token
663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
| ^
p808.cpp:663:47: error: 'constexpr' does not name a type
663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
| ^~~~~~~~~
p808.cpp:663:47: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:665:1: error: expected unqualified-id before 'return'
665 | return append(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
| ^~~~~~
p808.cpp:666:1: error: 'constexpr' does not name a type
666 | constexpr basic_string& append(initializer_list<charT> il);
| ^~~~~~~~~
p808.cpp:666:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:668:1: error: expected unqualified-id before 'return'
668 | return append(il.begin(), il.size());
| ^~~~~~
p808.cpp:669:6: error: 'constexpr' does not name a type
669 | constexpr void push_back(charT c);
| ^~~~~~~~~
p808.cpp:669:6: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:672:1: error: 'constexpr' does not name a type
672 | constexpr basic_string& assign(const basic_string& str);
| ^~~~~~~~~
p808.cpp:672:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:674:1: error: expected unqualified-id before 'return'
674 | return *this = str;
| ^~~~~~
p808.cpp:675:1: error: 'constexpr' does not name a type
675 | constexpr basic_string& assign(basic_string&& str)
| ^~~~~~~~~
p808.cpp:675:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:679:1: error: expected unqualified-id before 'return'
679 | return *this = std::move(str);
| ^~~~~~
p808.cpp:680:1: error: 'constexpr' does not name a type
680 | constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
| ^~~~~~~~~
p808.cpp:680:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:682:1: error: expected unqualified-id before 'return'
682 | return assign(basic_string_view<charT, traits>(str).substr(pos, n));
| ^~~~~~
p808.cpp:684:3: error: 'constexpr' does not name a type
684 | constexpr basic_string& assign(const T& t);
| ^~~~~~~~~
p808.cpp:684:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:687:1: error: 'basic_string_view' does not name a type
687 | basic_string_view<charT, traits> sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:688:3: error: expected unqualified-id before 'return'
688 | return assign(sv.data(), sv.size());
| ^~~~~~
p808.cpp:690:3: error: 'constexpr' does not name a type
690 | constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
| ^~~~~~~~~
p808.cpp:690:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:693:1: error: 'basic_string_view' does not name a type
693 | basic_string_view<charT, traits> sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:694:3: error: expected unqualified-id before 'return'
694 | return assign(sv.substr(pos, n));
| ^~~~~~
p808.cpp:695:1: error: 'constexpr' does not name a type
695 | constexpr basic_string& assign(const charT* s, size_type n);
| ^~~~~~~~~
p808.cpp:695:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:698:1: error: 'constexpr' does not name a type
698 | constexpr basic_string& assign(const charT* s);
| ^~~~~~~~~
p808.cpp:698:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:700:1: error: expected unqualified-id before 'return'
700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
| ^~~~~~
p808.cpp:700:38: error: 'constexpr' does not name a type
700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
| ^~~~~~~~~
p808.cpp:700:38: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:702:1: error: expected unqualified-id before 'return'
702 | return assign(il.begin(), il.size());
| ^~~~~~
p808.cpp:703:1: error: 'constexpr' does not name a type
703 | constexpr basic_string& assign(size_type n, charT c);
| ^~~~~~~~~
p808.cpp:703:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:705:10: error: expected constructor, destructor, or type conversion before ';' token
705 | clear();
| ^
p808.cpp:706:9: error: expected constructor, destructor, or type conversion before '(' token
706 | resize(n, c);
| ^
p808.cpp:707:3: error: expected unqualified-id before 'return'
707 | return *this;
| ^~~~~~
p808.cpp:709:3: error: 'constexpr' does not name a type
709 | constexpr basic_string& assign(InputIterator first, InputIterator last);
| ^~~~~~~~~
p808.cpp:709:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:712:1: error: expected unqualified-id before 'return'
712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
| ^~~~~~
p808.cpp:712:69: error: 'container' has not been declared
712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:712:78: error: expected '>' before '-' token
712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
| ^
p808.cpp:713:1: error: 'constexpr' does not name a type
713 | constexpr basic_string& assign_range(R&& rg);
| ^~~~~~~~~
p808.cpp:713:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:715:1: error: expected unqualified-id before 'return'
715 | return assign(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
| ^~~~~~
p808.cpp:717:1: error: 'constexpr' does not name a type
717 | constexpr basic_string& insert(size_type pos, const basic_string& str);
| ^~~~~~~~~
p808.cpp:717:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:719:1: error: expected unqualified-id before 'return'
719 | return insert(pos, str.data(), str.size());
| ^~~~~~
p808.cpp:720:1: error: 'constexpr' does not name a type
720 | constexpr basic_string& insert(size_type pos1, const basic_string& str,
| ^~~~~~~~~
p808.cpp:720:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:723:1: error: expected unqualified-id before 'return'
723 | return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
| ^~~~~~
p808.cpp:725:3: error: 'constexpr' does not name a type
725 | constexpr basic_string& insert(size_type pos, const T& t);
| ^~~~~~~~~
p808.cpp:725:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:728:3: error: expected unqualified-id before 'return'
728 | return insert(pos, sv.data(), sv.size());
| ^~~~~~
p808.cpp:730:3: error: 'constexpr' does not name a type
730 | constexpr basic_string& insert(size_type pos1, const T& t,
| ^~~~~~~~~
p808.cpp:730:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:734:3: error: expected unqualified-id before 'return'
734 | return insert(pos1, sv.substr(pos2, n));
| ^~~~~~
p808.cpp:735:1: error: 'constexpr' does not name a type
735 | constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
| ^~~~~~~~~
p808.cpp:735:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:741:1: error: 'constexpr' does not name a type
741 | constexpr basic_string& insert(size_type pos, const charT* s);
| ^~~~~~~~~
p808.cpp:741:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:743:1: error: 'constexpr' does not name a type
743 | constexpr basic_string& insert(size_type pos, size_type n, charT c);
| ^~~~~~~~~
p808.cpp:743:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:749:1: error: 'constexpr' does not name a type
749 | constexpr iterator insert(const_iterator p, charT c);
| ^~~~~~~~~
p808.cpp:749:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:753:1: error: 'constexpr' does not name a type
753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
| ^~~~~~~~~
p808.cpp:753:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:758:3: error: 'constexpr' does not name a type
758 | constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
| ^~~~~~~~~
p808.cpp:758:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:762:10: error: 'container' has not been declared
762 | template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:762:19: error: expected '>' before '-' token
762 | template<container-compatible-range<charT> R>
| ^
p808.cpp:763:1: error: 'constexpr' does not name a type
763 | constexpr iterator insert_range(const_iterator p, R&& rg);
| ^~~~~~~~~
p808.cpp:763:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:767:1: error: 'constexpr' does not name a type
767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
| ^~~~~~~~~
p808.cpp:767:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:770:1: error: 'constexpr' does not name a type
770 | constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
| ^~~~~~~~~
p808.cpp:770:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:774:1: error: 'constexpr' does not name a type
774 | constexpr iterator erase(const_iterator p);
| ^~~~~~~~~
p808.cpp:774:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:778:1: error: 'constexpr' does not name a type
778 | constexpr iterator erase(const_iterator first, const_iterator last);
| ^~~~~~~~~
p808.cpp:778:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:782:7: error: 'constexpr' does not name a type
782 | constexpr void pop_back();
| ^~~~~~~~~
p808.cpp:782:7: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:787:1: error: 'constexpr' does not name a type
787 | constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
| ^~~~~~~~~
p808.cpp:787:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:789:1: error: expected unqualified-id before 'return'
789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~
p808.cpp:789:51: error: 'constexpr' does not name a type
789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
p808.cpp:789:51: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:792:1: error: expected unqualified-id before 'return'
792 | return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
| ^~~~~~
p808.cpp:794:3: error: 'constexpr' does not name a type
794 | constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
| ^~~~~~~~~
p808.cpp:794:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:797:3: error: expected unqualified-id before 'return'
797 | return replace(pos1, n1, sv.data(), sv.size());
| ^~~~~~
p808.cpp:799:3: error: 'constexpr' does not name a type
799 | constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
| ^~~~~~~~~
p808.cpp:799:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:803:1: error: 'basic_string_view' does not name a type
803 | basic_string_view<charT, traits> sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:804:3: error: expected unqualified-id before 'return'
804 | return replace(pos1, n1, sv.substr(pos2, n2));
| ^~~~~~
p808.cpp:805:1: error: 'constexpr' does not name a type
805 | constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
| ^~~~~~~~~
p808.cpp:805:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:810:1: error: 'constexpr' does not name a type
810 | constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
| ^~~~~~~~~
p808.cpp:810:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:816:1: error: 'constexpr' does not name a type
816 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
| ^~~~~~~~~
p808.cpp:816:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:818:1: error: 'constexpr' does not name a type
818 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
| ^~~~~~~~~
p808.cpp:818:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:822:6: error: 'basic_string_view' does not name a type
822 | basic_string_view<charT, traits> sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:823:6: error: expected unqualified-id before 'return'
823 | return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
| ^~~~~~
p808.cpp:824:1: error: 'constexpr' does not name a type
824 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
| ^~~~~~~~~
p808.cpp:824:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:827:1: error: 'constexpr' does not name a type
827 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
| ^~~~~~~~~
p808.cpp:827:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:831:3: error: 'constexpr' does not name a type
831 | constexpr basic_string& replace(const_iterator i1, const_iterator i2,
| ^~~~~~~~~
p808.cpp:831:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:835:10: error: 'container' has not been declared
835 | template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:835:19: error: expected '>' before '-' token
835 | template<container-compatible-range<charT> R>
| ^
p808.cpp:836:1: error: 'constexpr' does not name a type
836 | constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
| ^~~~~~~~~
p808.cpp:836:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:838:1: error: expected unqualified-id before 'return'
838 | return replace(i1, i2, basic_string(from_range, std::forward<R>(rg), get_allocator()));
| ^~~~~~
p808.cpp:839:1: error: 'constexpr' does not name a type
839 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
| ^~~~~~~~~
p808.cpp:839:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:842:1: error: 'constexpr' does not name a type
842 | constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
| ^~~~~~~~~
p808.cpp:842:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:844:1: error: expected unqualified-id before 'return'
844 | return basic_string_view<charT, traits>(*this).copy(s, n, pos);
| ^~~~~~
p808.cpp:847:1: error: 'constexpr' does not name a type
847 | constexpr void swap(basic_string& s)
| ^~~~~~~~~
p808.cpp:847:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:852:1: error: 'constexpr' does not name a type
852 | constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
| ^~~~~~~~~
p808.cpp:852:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:854:1: error: expected unqualified-id before 'return'
854 | return F (basic_string_view<charT, traits>(str), pos);
| ^~~~~~
p808.cpp:856:1: error: 'constexpr' does not name a type
856 | constexpr size_type F(const charT* s, size_type pos) const;
| ^~~~~~~~~
p808.cpp:856:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:858:1: error: expected unqualified-id before 'return'
858 | return F (basic_string_view<charT, traits>(s), pos);
| ^~~~~~
p808.cpp:860:1: error: 'constexpr' does not name a type
860 | constexpr size_type F(const charT* s, size_type pos, size_type n) const;
| ^~~~~~~~~
p808.cpp:860:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:863:1: error: 'constexpr' does not name a type
863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
| ^~~~~~~~~
p808.cpp:863:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:863:63: error: 'has' does not name a type
863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
| ^~~
p808.cpp:866:1: error: 'constexpr' does not name a type
866 | constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
| ^~~~~~~~~
p808.cpp:866:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:868:1: error: 'constexpr' does not name a type
868 | constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see_below);
| ^~~~~~~~~
p808.cpp:868:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:870:1: error: 'constexpr' does not name a type
870 | constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see_below);
| ^~~~~~~~~
p808.cpp:870:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:872:1: error: 'constexpr' does not name a type
872 | constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see_below);
| ^~~~~~~~~
p808.cpp:872:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:874:1: error: 'constexpr' does not name a type
874 | constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see_below);
| ^~~~~~~~~
p808.cpp:874:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:880:1: error: 'constexpr' does not name a type
880 | constexpr const charT* c_str() const noexcept;
| ^~~~~~~~~
p808.cpp:880:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:881:1: error: 'constexpr' does not name a type
881 | constexpr const charT* data() const noexcept;
| ^~~~~~~~~
p808.cpp:881:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:884:1: error: 'constexpr' does not name a type
884 | constexpr charT* data() noexcept;
| ^~~~~~~~~
p808.cpp:884:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:887:1: error: 'constexpr' does not name a type
887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
| ^~~~~~~~~
p808.cpp:887:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:892:1: error: 'constexpr' does not name a type
892 | constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
| ^~~~~~~~~
p808.cpp:892:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:895:1: error: expected unqualified-id before 'return'
895 | return s.G(sv, pos);
| ^~~~~~
p808.cpp:898:1: error: 'constexpr' does not name a type
898 | constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
| ^~~~~~~~~
p808.cpp:898:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:902:1: error: 'constexpr' does not name a type
902 | constexpr int compare(const T& t) const noexcept(see_below);
| ^~~~~~~~~
p808.cpp:902:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:908:3: error: 'constexpr' does not name a type
908 | constexpr int compare(size_type pos1, size_type n1, const T& t) const;
| ^~~~~~~~~
p808.cpp:908:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:911:1: error: expected unqualified-id before 'return'
911 | return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
| ^~~~~~
p808.cpp:913:3: error: 'constexpr' does not name a type
913 | constexpr int compare(size_type pos1, size_type n1, const T& t,
| ^~~~~~~~~
p808.cpp:913:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:917:1: error: 'basic_string_view' does not name a type
917 | basic_string_view<charT, traits> s = *this, sv = t;
| ^~~~~~~~~~~~~~~~~
p808.cpp:918:8: error: expected unqualified-id before 'return'
918 | return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
| ^~~~~~
p808.cpp:919:1: error: 'constexpr' does not name a type
919 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~~~
p808.cpp:919:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:41: error: 'traits' was not declared in this scope
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
| alloca
p808.cpp:922:58: error: template argument 1 is invalid
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^
p808.cpp:922:58: error: template argument 2 is invalid
p808.cpp:922:58: error: template argument 3 is invalid
p808.cpp:922:72: error: 'charT' does not name a type; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:83: error: expected constructor, destructor, or type conversion before ';' token
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:45: error: template argument 1 is invalid
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^
p808.cpp:924:45: error: template argument 2 is invalid
p808.cpp:924:45: error: template argument 3 is invalid
p808.cpp:924:51: error: 'lhs' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~
p808.cpp:925:8: error: 'r' does not name a type
925 | r.append(rhs);
| ^
p808.cpp:926:8: error: expected unqualified-id before 'return'
926 | return r;
| ^~~~~~
p808.cpp:928:3: error: 'constexpr' does not name a type
928 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:928:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:931:4: error: 'constexpr' does not name a type
931 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
p808.cpp:931:4: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:934:1: error: expected unqualified-id before 'return'
934 | return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
| ^~~~~~
p808.cpp:935:1: error: 'constexpr' does not name a type
935 | constexpr int compare(const charT* s) const;
| ^~~~~~~~~
p808.cpp:935:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:938:1: error: 'constexpr' does not name a type
938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
p808.cpp:938:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:941:1: error: 'constexpr' does not name a type
941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:941:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:942:1: error: 'constexpr' does not name a type
942 | constexpr bool starts_with(charT x) const noexcept;
| ^~~~~~~~~
p808.cpp:942:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:943:1: error: 'constexpr' does not name a type
943 | constexpr bool starts_with(const charT* x) const;
| ^~~~~~~~~
p808.cpp:943:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:945:1: error: expected unqualified-id before 'return'
945 | return basic_string_view<charT, traits>(data(), size()).starts_with(x);
| ^~~~~~
p808.cpp:947:1: error: 'constexpr' does not name a type
947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:947:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:948:1: error: 'constexpr' does not name a type
948 | constexpr bool ends_with(charT x) const noexcept;
| ^~~~~~~~~
p808.cpp:948:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:949:1: error: 'constexpr' does not name a type
949 | constexpr bool ends_with(const charT* x) const;
| ^~~~~~~~~
p808.cpp:949:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:951:1: error: expected unqualified-id before 'return'
951 | return basic_string_view<charT, traits>(data(), size()).ends_with(x);
| ^~~~~~
p808.cpp:953:1: error: 'constexpr' does not name a type
953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:953:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:954:1: error: 'constexpr' does not name a type
954 | constexpr bool contains(charT x) const noexcept;
| ^~~~~~~~~
p808.cpp:954:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:955:1: error: 'constexpr' does not name a type
955 | constexpr bool contains(const charT* x) const;
| ^~~~~~~~~
p808.cpp:955:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:957:1: error: expected unqualified-id before 'return'
957 | return basic_string_view<charT, traits>(data(), size()).contains(x);
| ^~~~~~
p808.cpp:961:3: error: 'constexpr' does not name a type
961 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:961:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:965:3: error: 'constexpr' does not name a type
965 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:965:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:970:8: error: expected unqualified-id before 'return'
970 | return std::move(lhs);
| ^~~~~~
p808.cpp:971:17: error: 'charT' does not name a type; did you mean 'char'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~
| char
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~
| char
p808.cpp:971:49: error: 'traits' was not declared in this scope
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~~~~
| alloca
p808.cpp:971:66: error: template argument 1 is invalid
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^
p808.cpp:971:66: error: template argument 2 is invalid
p808.cpp:971:66: error: template argument 3 is invalid
p808.cpp:971:67: error: expected ',' or '...' before '&&' token
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~
p808.cpp:971:74: error: expected constructor, destructor, or type conversion before ';' token
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^
p808.cpp:973:4: error: expected unqualified-id before 'return'
973 | return std::move(rhs);
| ^~~~~~
p808.cpp:975:3: error: 'constexpr' does not name a type
975 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:975:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:979:4: error: expected unqualified-id before 'return'
979 | return std::move(lhs);
| ^~~~~~
p808.cpp:983:3: error: 'constexpr' does not name a type
983 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:983:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:987:3: error: 'constexpr' does not name a type
987 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:987:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:41: error: template argument 1 is invalid
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^
p808.cpp:992:41: error: template argument 2 is invalid
p808.cpp:992:41: error: template argument 3 is invalid
p808.cpp:992:43: error: redefinition of 'int r'
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^
p808.cpp:924:47: note: 'int r' previously defined here
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^
p808.cpp:992:47: error: 'rhs' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~
p808.cpp:993:4: error: 'r' does not name a type
993 | r.insert(0, lhs);
| ^
p808.cpp:994:4: error: expected unqualified-id before 'return'
994 | return r;
| ^~~~~~
p808.cpp:996:3: error: 'constexpr' does not name a type
996 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:996:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:41: error: template argument 1 is invalid
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^
p808.cpp:999:41: error: template argument 2 is invalid
p808.cpp:999:41: error: template argument 3 is invalid
p808.cpp:999:43: error: redefinition of 'int r'
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^
p808.cpp:924:47: note: 'int r' previously defined here
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^
p808.cpp:999:47: error: 'rhs' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~
p808.cpp:1000:4: error: 'r' does not name a type
1000 | r.insert(r.begin(), lhs);
| ^
p808.cpp:1001:4: error: expected unqualified-id before 'return'
1001 | return r;
| ^~~~~~
p808.cpp:1003:3: error: 'constexpr' does not name a type
1003 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:1003:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1006:4: error: expected unqualified-id before 'return'
1006 | return std::move(rhs);
| ^~~~~~
p808.cpp:1008:3: error: 'constexpr' does not name a type
1008 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:1008:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:41: error: template argument 1 is invalid
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^
p808.cpp:1011:41: error: template argument 2 is invalid
p808.cpp:1011:41: error: template argument 3 is invalid
p808.cpp:1011:43: error: redefinition of 'int r'
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^
p808.cpp:924:47: note: 'int r' previously defined here
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^
p808.cpp:1011:47: error: 'lhs' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~
p808.cpp:1012:4: error: 'r' does not name a type
1012 | r.push_back(rhs);
| ^
p808.cpp:1013:4: error: expected unqualified-id before 'return'
1013 | return r;
| ^~~~~~
p808.cpp:1014:1: error: 'constexpr' does not name a type
1014 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
p808.cpp:1014:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1016:1: error: expected unqualified-id before 'return'
1016 | return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);
| ^~~~~~
p808.cpp:1018:3: error: 'constexpr' does not name a type
1018 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~
p808.cpp:1018:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1021:8: error: expected unqualified-id before 'return'
1021 | return std::move(lhs);
| ^~~~~~
p808.cpp:1024:3: error: 'constexpr' does not name a type
1024 | constexpr bool
| ^~~~~~~~~
p808.cpp:1024:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1028:3: error: 'constexpr' does not name a type
1028 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~
p808.cpp:1028:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1031:1: error: 'constexpr' does not name a type
1031 | constexpr see_below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~
p808.cpp:1031:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1035:10: error: declaration of template parameter 'charT' shadows template parameter
1035 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1033:10: note: template parameter 'charT' declared here
1033 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1035:23: error: declaration of template parameter 'traits' shadows template parameter
1035 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1033:23: note: template parameter 'traits' declared here
1033 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1035:37: error: declaration of template parameter 'Allocator' shadows template parameter
1035 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1033:37: note: template parameter 'Allocator' declared here
1033 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1036:3: error: 'constexpr' does not name a type
1036 | constexpr void
| ^~~~~~~~~
p808.cpp:1036:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1063:41: error: expected ',' or '...' before '&&' token
1063 | getline(basic_istream<charT, traits>&& is,
| ^~
p808.cpp:1078:37: error: expected ',' or '...' before '&&' token
1078 | getline(basic_istream<charT, traits>&& is,
| ^~
p808.cpp:1083:3: error: 'constexpr' does not name a type
1083 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~
p808.cpp:1083:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1086:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
1086 | auto it = remove(c.begin(), c.end(), value);
| ^~~~
| ----
p808.cpp:1086:9: error: 'it' does not name a type; did you mean 'int'?
1086 | auto it = remove(c.begin(), c.end(), value);
| ^~
| int
p808.cpp:1087:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
1087 | auto r = distance(it, c.end());
| ^~~~
| ----
p808.cpp:1087:9: error: 'r' does not name a type
1087 | auto r = distance(it, c.end());
| ^
p808.cpp:1088:4: error: 'c' does not name a type
1088 | c.erase(it, c.end());
| ^
p808.cpp:1089:4: error: expected unqualified-id before 'return'
1089 | return r;
| ^~~~~~
p808.cpp:1091:3: error: 'constexpr' does not name a type
1091 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~
p808.cpp:1091:3: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1094:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
1094 | auto it = remove_if(c.begin(), c.end(), pred);
| ^~~~
| ----
p808.cpp:1094:9: error: 'it' does not name a type; did you mean 'int'?
1094 | auto it = remove_if(c.begin(), c.end(), pred);
| ^~
| int
p808.cpp:1095:4: warning: 'auto' changes meaning in C++11; please remove it [-Wc++11-compat]
1095 | auto r = distance(it, c.end());
| ^~~~
| ----
p808.cpp:1095:9: error: 'r' does not name a type
1095 | auto r = distance(it, c.end());
| ^
p808.cpp:1096:4: error: 'c' does not name a type
1096 | c.erase(it, c.end());
| ^
p808.cpp:1097:4: error: expected unqualified-id before 'return'
1097 | return r;
| ^~~~~~
p808.cpp:1100:46: error: 'nullptr' was not declared in this scope
1100 | int stoi(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1101:47: error: 'nullptr' was not declared in this scope
1101 | long stol(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1102:57: error: 'nullptr' was not declared in this scope
1102 | unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1103:53: error: 'nullptr' was not declared in this scope
1103 | long long stoll(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1104:63: error: 'nullptr' was not declared in this scope
1104 | unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1108:45: error: 'nullptr' was not declared in this scope
1108 | float stof(const string& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:1109:46: error: 'nullptr' was not declared in this scope
1109 | double stod(const string& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:1110:52: error: 'nullptr' was not declared in this scope
1110 | long double stold(const string& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:1123:44: error: 'nullptr' was not declared in this scope
1123 | int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1124:45: error: 'nullptr' was not declared in this scope
1124 | long stol(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1125:55: error: 'nullptr' was not declared in this scope
1125 | unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1126:51: error: 'nullptr' was not declared in this scope
1126 | long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1127:61: error: 'nullptr' was not declared in this scope
1127 | unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);
| ^~~~~~~
p808.cpp:1133:46: error: 'nullptr' was not declared in this scope
1133 | float stof(const wstring& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:1134:47: error: 'nullptr' was not declared in this scope
1134 | double stod(const wstring& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:1135:53: error: 'nullptr' was not declared in this scope
1135 | long double stold(const wstring& str, size_t* idx = nullptr);
| ^~~~~~~
p808.cpp:1150:19: error: explicit specialization of 'template<class T> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1150 | template<> struct hash<string>;
| ^~~~~~~~~~~~
p808.cpp:1151:24: error: 'u8string' was not declared in this scope
1151 | template<> struct hash<u8string>;
| ^~~~~~~~
p808.cpp:1151:24: note: 'std::u8string' is only available from C++20 onwards
p808.cpp:1151:32: error: template argument 1 is invalid
1151 | template<> struct hash<u8string>;
| ^
p808.cpp:1152:24: error: 'u16string' was not declared in this scope
1152 | template<> struct hash<u16string>;
| ^~~~~~~~~
p808.cpp:1152:24: note: 'std::u16string' is only available from C++11 onwards
p808.cpp:1152:33: error: template argument 1 is invalid
1152 | template<> struct hash<u16string>;
| ^
p808.cpp:1153:24: error: 'u32string' was not declared in this scope
1153 | template<> struct hash<u32string>;
| ^~~~~~~~~
p808.cpp:1153:24: note: 'std::u32string' is only available from C++11 onwards
p808.cpp:1153:33: error: template argument 1 is invalid
1153 | template<> struct hash<u32string>;
| ^
p808.cpp:1154:19: error: explicit specialization of 'template<class T> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1154 | template<> struct hash<wstring>;
| ^~~~~~~~~~~~~
p808.cpp:1155:29: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
1155 | template<> struct hash<pmr::string>;
| ^~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:77:33: note: 'std::string' declared here
77 | typedef basic_string<char> string;
| ^~~~~~
p808.cpp:1155:29: error: 'string' is not a member of 'std::pmr'; did you mean 'std::string'?
1155 | template<> struct hash<pmr::string>;
| ^~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:77:33: note: 'std::string' declared here
77 | typedef basic_string<char> string;
| ^~~~~~
p808.cpp:1155:35: error: template argument 1 is invalid
1155 | template<> struct hash<pmr::string>;
| ^
p808.cpp:1156:29: error: 'u8string' is not a member of 'std::pmr'
1156 | template<> struct hash<pmr::u8string>;
| ^~~~~~~~
p808.cpp:1156:29: error: 'u8string' is not a member of 'std::pmr'
p808.cpp:1156:37: error: template argument 1 is invalid
1156 | template<> struct hash<pmr::u8string>;
| ^
p808.cpp:1157:29: error: 'u16string' is not a member of 'std::pmr'
1157 | template<> struct hash<pmr::u16string>;
| ^~~~~~~~~
p808.cpp:1157:29: error: 'u16string' is not a member of 'std::pmr'
p808.cpp:1157:38: error: template argument 1 is invalid
1157 | template<> struct hash<pmr::u16string>;
| ^
p808.cpp:1158:29: error: 'u32string' is not a member of 'std::pmr'
1158 | template<> struct hash<pmr::u32string>;
| ^~~~~~~~~
p808.cpp:1158:29: error: 'u32string' is not a member of 'std::pmr'
p808.cpp:1158:38: error: template argument 1 is invalid
1158 | template<> struct hash<pmr::u32string>;
| ^
p808.cpp:1159:29: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
1159 | template<> struct hash<pmr::wstring>;
| ^~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
80 | typedef basic_string<wchar_t> wstring;
| ^~~~~~~
p808.cpp:1159:29: error: 'wstring' is not a member of 'std::pmr'; did you mean 'std::wstring'?
1159 | template<> struct hash<pmr::wstring>;
| ^~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:80:33: note: 'std::wstring' declared here
80 | typedef basic_string<wchar_t> wstring;
| ^~~~~~~
p808.cpp:1159:36: error: template argument 1 is invalid
1159 | template<> struct hash<pmr::wstring>;
| ^
p808.cpp:1161:1: error: 'constexpr' does not name a type
1161 | constexpr string operator""s(const char* str, size_t len);
| ^~~~~~~~~
p808.cpp:1161:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1163:1: error: 'constexpr' does not name a type
1163 | constexpr u8string operator""s(const char8_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:1163:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1165:1: error: 'constexpr' does not name a type
1165 | constexpr u16string operator""s(const char16_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:1165:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1167:1: error: 'constexpr' does not name a type
1167 | constexpr u32string operator""s(const char32_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:1167:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
p808.cpp:1169:1: error: 'constexpr' does not name a type
1169 | constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~~
p808.cpp:1169:1: note: C++11 'constexpr' only available with '-std=c++11' or '-std=gnu++11'
$ g++ p808.cpp -std=2b -o p808g -I. -Wall
p808.cpp:660:75: error: too many decimal points in number
660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
| ^~~~~~~~
p808.cpp:24:17: error: reference to 'basic_string' is ambiguous
24 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
In file included from /usr/local/include/c++/12.1.0/iosfwd:39,
from /usr/local/include/c++/12.1.0/ios:38,
from /usr/local/include/c++/12.1.0/ostream:38,
from /usr/local/include/c++/12.1.0/iostream:39,
from N4910.h:2,
from p808.cpp:10:
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:28:17: error: reference to 'basic_string' is ambiguous
28 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:32:17: error: reference to 'basic_string' is ambiguous
32 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:36:13: error: reference to 'basic_string' is ambiguous
36 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:40:13: error: reference to 'basic_string' is ambiguous
40 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:44:13: error: reference to 'basic_string' is ambiguous
44 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:48:13: error: reference to 'basic_string' is ambiguous
48 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:52:13: error: reference to 'basic_string' is ambiguous
52 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:56:13: error: reference to 'basic_string' is ambiguous
56 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:60:13: error: reference to 'basic_string' is ambiguous
60 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:64:13: error: reference to 'basic_string' is ambiguous
64 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:68:13: error: reference to 'basic_string' is ambiguous
68 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:73:22: error: reference to 'basic_string' is ambiguous
73 | operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:73:34: error: expected ',' or '...' before '<' token
73 | operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^
p808.cpp:73:5: error: 'constexpr bool std::operator==(int)' must have an argument of class or enumerated type
73 | operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~
p808.cpp:76:35: error: reference to 'basic_string' is ambiguous
76 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:76:47: error: expected ',' or '...' before '<' token
76 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^
p808.cpp:76:18: error: 'constexpr bool std::operator==(int)' must have an argument of class or enumerated type
76 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~
p808.cpp:79:11: error: 'see' does not name a type
79 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
| ^~~
p808.cpp:82:11: error: 'see' does not name a type
82 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~
p808.cpp:86:5: error: variable or field 'swap' declared void
86 | swap(basic_string<charT, traits, Allocator>& lhs,
| ^~~~
p808.cpp:86:10: error: reference to 'basic_string' is ambiguous
86 | swap(basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:86:28: error: expected primary-expression before ',' token
86 | swap(basic_string<charT, traits, Allocator>& lhs,
| ^
p808.cpp:86:36: error: expected primary-expression before ',' token
86 | swap(basic_string<charT, traits, Allocator>& lhs,
| ^
p808.cpp:86:47: error: expected primary-expression before '>' token
86 | swap(basic_string<charT, traits, Allocator>& lhs,
| ^
p808.cpp:86:50: error: 'lhs' was not declared in this scope
86 | swap(basic_string<charT, traits, Allocator>& lhs,
| ^~~
p808.cpp:87:10: error: reference to 'basic_string' is ambiguous
87 | basic_string<charT, traits, Allocator>& rhs)
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:87:28: error: expected primary-expression before ',' token
87 | basic_string<charT, traits, Allocator>& rhs)
| ^
p808.cpp:87:36: error: expected primary-expression before ',' token
87 | basic_string<charT, traits, Allocator>& rhs)
| ^
p808.cpp:87:47: error: expected primary-expression before '>' token
87 | basic_string<charT, traits, Allocator>& rhs)
| ^
p808.cpp:87:50: error: 'rhs' was not declared in this scope
87 | basic_string<charT, traits, Allocator>& rhs)
| ^~~
p808.cpp:93:1: error: reference to 'basic_string' is ambiguous
93 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:93:1: error: 'basic_string' has not been declared
93 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:93:13: error: expected ',' or '...' before '<' token
93 | basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:97:22: error: reference to 'basic_string' is ambiguous
97 | const basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:97:34: error: expected ',' or '...' before '<' token
97 | const basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:101:13: error: reference to 'basic_string' is ambiguous
101 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:101:13: error: 'basic_string' has not been declared
101 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
p808.cpp:101:25: error: expected ',' or '...' before '<' token
101 | basic_string<charT, traits, Allocator>& str,
| ^
p808.cpp:106:13: error: reference to 'basic_string' is ambiguous
106 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:106:13: error: 'basic_string' has not been declared
106 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
p808.cpp:106:25: error: expected ',' or '...' before '<' token
106 | basic_string<charT, traits, Allocator>& str,
| ^
p808.cpp:111:13: error: reference to 'basic_string' is ambiguous
111 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:111:13: error: 'basic_string' has not been declared
111 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:111:25: error: expected ',' or '...' before '<' token
111 | basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:115:13: error: reference to 'basic_string' is ambiguous
115 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:115:13: error: 'basic_string' has not been declared
115 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:115:25: error: expected ',' or '...' before '<' token
115 | basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:118:22: error: expected nested-name-specifier before 'basic_string'
118 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~~~~
p808.cpp:118:34: error: expected initializer before '<' token
118 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^
p808.cpp:121:22: error: expected nested-name-specifier before 'basic_string'
121 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~~~~
p808.cpp:121:34: error: expected initializer before '<' token
121 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^
p808.cpp:124:16: error: reference to 'basic_string' is ambiguous
124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:124:53: error: reference to 'basic_string' is ambiguous
124 | using string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:124:94: error: reference to 'basic_string' is ambiguous
124 | ng string = basic_string<char>; using u8string = basic_string<char8_t>; using u16string = basic_strin<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:124:136: error: reference to 'basic_string' is ambiguous
124 | ring = basic_string<char8_t>; using u16string = basic_string<char16_t>; using u32string = basic_strin<char32_t>; using wstring = basic_string<wchar_t>;
| ^~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:124:176: error: reference to 'basic_string' is ambiguous
124 | tring = basic_string<char16_t>; using u32string = basic_string<char32_t>; using wstring = basic_strin<wchar_t>;
| ^~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:161:28: error: reference to 'basic_string' is ambiguous
161 | using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;
| ^~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:173:18: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~
p808.cpp:173:79: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
173 | constexpr string operator""s(const char* str, size_t len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~
p808.cpp:173:144: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
173 | len); constexpr u8string operator""s(const char8_t* str, size_t len); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~
p808.cpp:173:210: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
173 | n); constexpr u16string operator""s(const char16_t* str, size_t len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~
p808.cpp:173:274: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
173 | len); constexpr u32string operator""s(const char32_t* str, size_t len); constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~
p808.cpp:182:30: error: redefinition of default argument for 'class traits'
182 | template<class charT, class traits = char_traits<charT>,
| ^~~~~
p808.cpp:21:23: note: original definition appeared here
21 | template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
| ^~~~~
p808.cpp:404:31: error: reference to 'basic_string' is ambiguous
404 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: candidates are: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:404:56: error: non-member function 'constexpr int std::compare(const int&)' cannot have cv-qualifier
404 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~~
p808.cpp:405:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
405 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
| ^~~~~~~~~
p808.cpp:404:17: note: previous declaration 'constexpr int std::compare(const int&)'
404 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~
p808.cpp:405:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
405 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
| ^~~~~~~~~
| true_type
p808.cpp:405:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
405 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
| ^~~~~~~~~
| true_type
p808.cpp:405:55: error: expected primary-expression before 'const'
405 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;
| ^~~~~
p808.cpp:406:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
406 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
p808.cpp:404:17: note: previous declaration 'constexpr int std::compare(const int&)'
404 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~
p808.cpp:406:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
406 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
| true_type
p808.cpp:406:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
406 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
| true_type
p808.cpp:406:55: error: expected primary-expression before 'const'
406 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~
p808.cpp:407:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
407 | size_type pos2, size_type n2 = npos) const;
| ^~~~~~~~~
| true_type
p808.cpp:407:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
407 | size_type pos2, size_type n2 = npos) const;
| ^~~~~~~~~
| true_type
p808.cpp:408:31: error: 'charT' does not name a type; did you mean 'char'?
408 | constexpr int compare(const charT* s) const;
| ^~~~~
| char
p808.cpp:408:41: error: non-member function 'constexpr int std::compare(const int*)' cannot have cv-qualifier
408 | constexpr int compare(const charT* s) const;
| ^~~~~
p808.cpp:409:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
409 | constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
| ^~~~~~~~~
p808.cpp:408:17: note: previous declaration 'constexpr int std::compare(const int*)'
408 | constexpr int compare(const charT* s) const;
| ^~~~~~~
p808.cpp:409:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
409 | constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
| ^~~~~~~~~
| true_type
p808.cpp:409:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
409 | constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
| ^~~~~~~~~
| true_type
p808.cpp:409:55: error: expected primary-expression before 'const'
409 | constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
| ^~~~~
p808.cpp:410:25: error: 'constexpr const int std::compare' redeclared as different kind of entity
410 | constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
p808.cpp:408:17: note: previous declaration 'constexpr int std::compare(const int*)'
408 | constexpr int compare(const charT* s) const;
| ^~~~~~~
p808.cpp:410:25: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
410 | constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
| true_type
p808.cpp:410:41: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
410 | constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
| true_type
p808.cpp:410:55: error: expected primary-expression before 'const'
410 | constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
| ^~~~~
p808.cpp:410:71: error: 'size_type' was not declared in this scope; did you mean 'true_type'?
410 | constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
| true_type
p808.cpp:411:48: error: 'charT' was not declared in this scope; did you mean 'char'?
411 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~
| char
p808.cpp:411:55: error: 'traits' was not declared in this scope
411 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~
p808.cpp:411:61: error: template argument 1 is invalid
411 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^
p808.cpp:411:61: error: template argument 2 is invalid
p808.cpp:411:72: error: non-member function 'constexpr bool std::starts_with(int)' cannot have cv-qualifier
411 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:412:30: error: 'constexpr const bool std::starts_with' redeclared as different kind of entity
412 | constexpr bool starts_with(charT x) const noexcept;
| ^~~~~
p808.cpp:411:18: note: previous declaration 'constexpr bool std::starts_with(int)'
411 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~~~
p808.cpp:412:30: error: 'charT' was not declared in this scope; did you mean 'char'?
412 | constexpr bool starts_with(charT x) const noexcept;
| ^~~~~
| char
p808.cpp:413:36: error: 'charT' does not name a type; did you mean 'char'?
413 | constexpr bool starts_with(const charT* x) const;
| ^~~~~
| char
p808.cpp:413:46: error: non-member function 'constexpr bool std::starts_with(const int*)' cannot have cv-qualifier
413 | constexpr bool starts_with(const charT* x) const;
| ^~~~~
p808.cpp:414:46: error: 'charT' was not declared in this scope; did you mean 'char'?
414 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~
| char
p808.cpp:414:53: error: 'traits' was not declared in this scope
414 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~
p808.cpp:414:59: error: template argument 1 is invalid
414 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^
p808.cpp:414:59: error: template argument 2 is invalid
p808.cpp:414:70: error: non-member function 'constexpr bool std::ends_with(int)' cannot have cv-qualifier
414 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:415:28: error: 'constexpr const bool std::ends_with' redeclared as different kind of entity
415 | constexpr bool ends_with(charT x) const noexcept;
| ^~~~~
p808.cpp:414:18: note: previous declaration 'constexpr bool std::ends_with(int)'
414 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:415:28: error: 'charT' was not declared in this scope; did you mean 'char'?
415 | constexpr bool ends_with(charT x) const noexcept;
| ^~~~~
| char
p808.cpp:416:34: error: 'charT' does not name a type; did you mean 'char'?
416 | constexpr bool ends_with(const charT* x) const;
| ^~~~~
| char
p808.cpp:416:44: error: non-member function 'constexpr bool std::ends_with(const int*)' cannot have cv-qualifier
416 | constexpr bool ends_with(const charT* x) const;
| ^~~~~
p808.cpp:417:45: error: 'charT' was not declared in this scope; did you mean 'char'?
417 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~
| char
p808.cpp:417:52: error: 'traits' was not declared in this scope
417 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~
p808.cpp:417:58: error: template argument 1 is invalid
417 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^
p808.cpp:417:58: error: template argument 2 is invalid
p808.cpp:417:69: error: non-member function 'constexpr bool std::contains(int)' cannot have cv-qualifier
417 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:418:27: error: 'constexpr const bool std::contains' redeclared as different kind of entity
418 | constexpr bool contains(charT x) const noexcept;
| ^~~~~
p808.cpp:417:18: note: previous declaration 'constexpr bool std::contains(int)'
417 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:418:27: error: 'charT' was not declared in this scope; did you mean 'char'?
418 | constexpr bool contains(charT x) const noexcept;
| ^~~~~
| char
p808.cpp:419:33: error: 'charT' does not name a type; did you mean 'char'?
419 | constexpr bool contains(const charT* x) const;
| ^~~~~
| char
p808.cpp:419:43: error: non-member function 'constexpr bool std::contains(const int*)' cannot have cv-qualifier
419 | constexpr bool contains(const charT* x) const;
| ^~~~~
p808.cpp:424:8: error: reference to 'basic_string' is ambiguous
424 | -> basic_string<typename iterator_traits<InputIterator>::value_type,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:423:3: error: reference to 'basic_string' is ambiguous
423 | basic_string(InputIterator, InputIterator, Allocator = Allocator())
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:424:20: error: expected constructor, destructor, or type conversion before '<' token
424 | -> basic_string<typename iterator_traits<InputIterator>::value_type,
| ^
p808.cpp:429:15: error: expected constructor, destructor, or type conversion before '(' token
429 | basic_string(from_range_t, R&&, Allocator = Allocator())
| ^
p808.cpp:436:8: error: reference to 'basic_string' is ambiguous
436 | -> basic_string<charT, traits, Allocator>;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:435:12: error: reference to 'basic_string' is ambiguous
435 | explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:436:20: error: expected initializer before '<' token
436 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:441:10: error: expected nested-name-specifier before 'see'
441 | typename see below::size_type, typename see below::size_type,
| ^~~
p808.cpp:441:14: error: expected ',' or '...' before 'below'
441 | typename see below::size_type, typename see below::size_type,
| ^~~~~
p808.cpp:443:4: error: reference to 'basic_string' is ambiguous
443 | -> basic_string<charT, traits, Allocator>;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:440:3: error: reference to 'basic_string' is ambiguous
440 | basic_string(basic_string_view<charT, traits>,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:443:16: error: expected constructor, destructor, or type conversion before '<' token
443 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:456:39: error: 'Allocator' does not name a type; did you mean 'alloca'?
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~
| alloca
p808.cpp:456:20: error: reference to 'basic_string' is ambiguous
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:456:20: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:456:11: error: 'explicit' outside class declaration
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~
p808.cpp:458:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
458 | constexpr basic_string(basic_string&& str) noexcept;
| ^~~~~~~~~~~~
p808.cpp:458:24: error: 'constexpr const int basic_string' redeclared as different kind of entity
458 | constexpr basic_string(basic_string&& str) noexcept;
| ^~~~~~~~~~~~
p808.cpp:456:20: note: previous declaration 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:458:24: error: reference to 'basic_string' is ambiguous
458 | constexpr basic_string(basic_string&& str) noexcept;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:458:39: error: 'str' was not declared in this scope; did you mean 'std'?
458 | constexpr basic_string(basic_string&& str) noexcept;
| ^~~
| std
p808.cpp:460:30: error: reference to 'basic_string' is ambiguous
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:460:49: error: 'size_type' has not been declared
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~
p808.cpp:461:30: error: 'Allocator' does not name a type; did you mean 'alloca'?
461 | const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:461:45: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
461 | const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:460:11: error: reference to 'basic_string' is ambiguous
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:460:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:462:30: error: reference to 'basic_string' is ambiguous
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:462:49: error: 'size_type' has not been declared
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~
p808.cpp:462:64: error: 'size_type' has not been declared
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~
p808.cpp:463:30: error: 'Allocator' does not name a type; did you mean 'alloca'?
463 | const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:463:45: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
463 | const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:462:11: error: reference to 'basic_string' is ambiguous
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:462:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:466:38: error: 'size_type' has not been declared
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:466:53: error: 'size_type' has not been declared
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:466:72: error: 'Allocator' does not name a type; did you mean 'alloca'?
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:466:87: error: there are no arguments to 'Allocator' that depend on a template parameter, so a declaration of 'Allocator' must be available [-fpermissive]
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:466:87: note: (if you use '-fpermissive', G++ will accept your code, but allowing the use of an undeclared name is deprecated)
p808.cpp:466:13: error: reference to 'basic_string' is ambiguous
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:466:13: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:468:15: error: expected constructor, destructor, or type conversion before '(' token
468 | basic_string(sv.substr(pos, n), a);
| ^
p808.cpp:470:53: error: 'Allocator' does not name a type; did you mean 'alloca'?
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:470:68: error: there are no arguments to 'Allocator' that depend on a template parameter, so a declaration of 'Allocator' must be available [-fpermissive]
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:470:22: error: reference to 'basic_string' is ambiguous
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:470:22: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:13: error: 'explicit' outside class declaration
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~
p808.cpp:474:30: error: 'charT' does not name a type; did you mean 'char'?
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~
| char
p808.cpp:474:40: error: 'size_type' has not been declared
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:474:59: error: 'Allocator' does not name a type; did you mean 'alloca'?
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:474:74: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:474:11: error: reference to 'basic_string' is ambiguous
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:474:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:30: error: 'charT' does not name a type; did you mean 'char'?
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~
| char
p808.cpp:478:46: error: 'Allocator' does not name a type; did you mean 'alloca'?
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:478:61: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:478:11: error: reference to 'basic_string' is ambiguous
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:478:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:482:11: error: reference to 'basic_string' is ambiguous
482 | constexpr basic_string& operator=(const basic_string& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:483:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:483:24: error: 'constexpr const int basic_string' redeclared as different kind of entity
483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:478:11: note: previous declaration 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:483:24: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
| ^~~~~~~~~
| size_t
p808.cpp:483:37: error: 'charT' was not declared in this scope; did you mean 'char'?
483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
| ^~~~~
| char
p808.cpp:483:46: error: expected primary-expression before 'const'
483 | constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());
| ^~~~~
p808.cpp:487:72: error: 'Allocator' does not name a type; did you mean 'alloca'?
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~
| alloca
p808.cpp:487:87: error: there are no arguments to 'Allocator' that depend on a template parameter, so a declaration of 'Allocator' must be available [-fpermissive]
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~
p808.cpp:487:13: error: reference to 'basic_string' is ambiguous
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:487:13: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:490:10: error: 'container' has not been declared
490 | template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:490:19: error: expected '>' before '-' token
490 | template<container-compatible-range<charT> R>
| ^
p808.cpp:491:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
| ^~~~~~~~~~~~
p808.cpp:491:24: error: 'template<<typeprefixerror><anonymous> > constexpr const int basic_string' redeclared as different kind of entity
491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: previous declaration 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:491:24: error: 'from_range_t' was not declared in this scope
491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
| ^~~~~~~~~~~~
p808.cpp:491:38: error: 'R' was not declared in this scope
491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
| ^
p808.cpp:491:42: error: 'rg' was not declared in this scope
491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
| ^~
p808.cpp:491:46: error: expected primary-expression before 'const'
491 | constexpr basic_string(from_range_t, R&& rg, const Allocator& = Allocator());
| ^~~~~
p808.cpp:494:30: error: reference to 'basic_string' is ambiguous
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:494:55: error: 'Allocator' does not name a type; did you mean 'alloca'?
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~
| alloca
p808.cpp:494:11: error: reference to 'basic_string' is ambiguous
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:494:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:495:11: error: ISO C++ forbids declaration of 'basic_string' with no type [-fpermissive]
495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:495:24: error: 'constexpr const int basic_string' redeclared as different kind of entity
495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:494:11: note: previous declaration 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:495:24: error: reference to 'basic_string' is ambiguous
495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:495:39: error: 'str' was not declared in this scope; did you mean 'std'?
495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
| ^~~
| std
p808.cpp:495:44: error: expected primary-expression before 'const'
495 | constexpr basic_string(basic_string&& str, const Allocator& alloc);
| ^~~~~
p808.cpp:501:6: error: reference to 'basic_string' is ambiguous
501 | -> basic_string<typename iterator_traits<InputIterator>::value_type,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:500:1: error: reference to 'basic_string' is ambiguous
500 | basic_string(InputIterator, InputIterator, Allocator = Allocator())
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:501:18: error: expected constructor, destructor, or type conversion before '<' token
501 | -> basic_string<typename iterator_traits<InputIterator>::value_type,
| ^
p808.cpp:509:8: error: reference to 'basic_string' is ambiguous
509 | -> basic_string<charT, traits, Allocator>;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:508:12: error: reference to 'basic_string' is ambiguous
508 | explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:509:20: error: expected initializer before '<' token
509 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:514:10: error: expected nested-name-specifier before 'see'
514 | typename see below::size_type, typename see below::size_type,
| ^~~
p808.cpp:514:14: error: expected ',' or '...' before 'below'
514 | typename see below::size_type, typename see below::size_type,
| ^~~~~
p808.cpp:516:8: error: reference to 'basic_string' is ambiguous
516 | -> basic_string<charT, traits, Allocator>;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:513:3: error: reference to 'basic_string' is ambiguous
513 | basic_string(basic_string_view<charT, traits>,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:516:20: error: expected constructor, destructor, or type conversion before '<' token
516 | -> basic_string<charT, traits, Allocator>;
| ^
p808.cpp:519:11: error: reference to 'basic_string' is ambiguous
519 | constexpr basic_string& operator=(basic_string&& str)
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:524:11: error: reference to 'basic_string' is ambiguous
524 | constexpr basic_string& operator=(const T& t);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:528:8: error: expected unqualified-id before 'return'
528 | return assign(sv);
| ^~~~~~
p808.cpp:529:11: error: reference to 'basic_string' is ambiguous
529 | constexpr basic_string& operator=(const charT* s);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:531:11: error: reference to 'basic_string' is ambiguous
531 | constexpr basic_string& operator=(charT c);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:533:1: error: expected unqualified-id before 'return'
533 | return *this = basic_string_view<charT, traits>(addressof(c), 1);
| ^~~~~~
p808.cpp:534:11: error: reference to 'basic_string' is ambiguous
534 | constexpr basic_string& operator=(initializer_list<charT> il);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:536:1: error: expected unqualified-id before 'return'
536 | return *this = basic_string_view<charT, traits>(il.begin(), il.size());
| ^~~~~~
p808.cpp:538:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
538 | constexpr iterator begin() noexcept;
| ^~~~~~~~
In file included from /usr/local/include/c++/12.1.0/bits/stl_construct.h:61,
from /usr/local/include/c++/12.1.0/bits/char_traits.h:46,
from /usr/local/include/c++/12.1.0/ios:40:
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:538:11: error: deduced class type 'iterator' in function return type
538 | constexpr iterator begin() noexcept;
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:539:11: error: 'const_iterator' does not name a type
539 | constexpr const_iterator begin() const noexcept;
| ^~~~~~~~~~~~~~
p808.cpp:540:11: error: 'const_iterator' does not name a type
540 | constexpr const_iterator cbegin() const noexcept;
| ^~~~~~~~~~~~~~
p808.cpp:542:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
542 | constexpr iterator end() noexcept;
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:542:11: error: deduced class type 'iterator' in function return type
542 | constexpr iterator end() noexcept;
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:543:11: error: 'const_iterator' does not name a type
543 | constexpr const_iterator end() const noexcept;
| ^~~~~~~~~~~~~~
p808.cpp:544:11: error: 'const_iterator' does not name a type
544 | constexpr const_iterator cend() const noexcept;
| ^~~~~~~~~~~~~~
p808.cpp:546:11: error: deduced class type 'reverse_iterator' in function return type
546 | constexpr reverse_iterator rbegin() noexcept;
| ^~~~~~~~~~~~~~~~
In file included from /usr/local/include/c++/12.1.0/string:47,
from /usr/local/include/c++/12.1.0/bits/locale_classes.h:40,
from /usr/local/include/c++/12.1.0/bits/ios_base.h:41,
from /usr/local/include/c++/12.1.0/ios:42:
/usr/local/include/c++/12.1.0/bits/stl_iterator.h:132:11: note: 'template<class _Iterator> class std::reverse_iterator' declared here
132 | class reverse_iterator
| ^~~~~~~~~~~~~~~~
p808.cpp:547:11: error: 'const_reverse_iterator' does not name a type
547 | constexpr const_reverse_iterator rbegin() const noexcept;
| ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:548:11: error: 'const_reverse_iterator' does not name a type
548 | constexpr const_reverse_iterator crbegin() const noexcept;
| ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:550:11: error: deduced class type 'reverse_iterator' in function return type
550 | constexpr reverse_iterator rend() noexcept;
| ^~~~~~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator.h:132:11: note: 'template<class _Iterator> class std::reverse_iterator' declared here
132 | class reverse_iterator
| ^~~~~~~~~~~~~~~~
p808.cpp:551:11: error: 'const_reverse_iterator' does not name a type
551 | constexpr const_reverse_iterator rend() const noexcept;
| ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:552:11: error: 'const_reverse_iterator' does not name a type
552 | constexpr const_reverse_iterator crend() const noexcept;
| ^~~~~~~~~~~~~~~~~~~~~~
p808.cpp:555:11: error: 'size_type' does not name a type; did you mean 'size_t'?
555 | constexpr size_type size() const noexcept;
| ^~~~~~~~~
| size_t
p808.cpp:556:11: error: 'size_type' does not name a type; did you mean 'size_t'?
556 | constexpr size_type length() const noexcept;
| ^~~~~~~~~
| size_t
p808.cpp:558:16: error: 'size_type' does not name a type; did you mean 'size_t'?
558 | constexpr size_type max_size() const noexcept;
| ^~~~~~~~~
| size_t
p808.cpp:560:16: error: variable or field 'resize' declared void
560 | constexpr void resize(size_type n, charT c);
| ^~~~~~
p808.cpp:560:23: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
560 | constexpr void resize(size_type n, charT c);
| ^~~~~~~~~
| size_t
p808.cpp:560:36: error: 'charT' was not declared in this scope; did you mean 'char'?
560 | constexpr void resize(size_type n, charT c);
| ^~~~~
| char
p808.cpp:563:16: error: variable or field 'resize' declared void
563 | constexpr void resize(size_type n);
| ^~~~~~
p808.cpp:563:23: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
563 | constexpr void resize(size_type n);
| ^~~~~~~~~
| size_t
p808.cpp:565:42: error: variable or field 'resize_and_overwrite' declared void
565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
| ^~~~~~~~~~~~~~~~~~~~
p808.cpp:565:63: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
| ^~~~~~~~~
| size_t
p808.cpp:565:86: error: expected primary-expression before 'op'
565 | template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
| ^~
p808.cpp:578:11: error: 'size_type' does not name a type; did you mean 'size_t'?
578 | constexpr size_type capacity() const noexcept;
| ^~~~~~~~~
| size_t
p808.cpp:580:16: error: variable or field 'reserve' declared void
580 | constexpr void reserve(size_type res_arg);
| ^~~~~~~
p808.cpp:580:24: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
580 | constexpr void reserve(size_type res_arg);
| ^~~~~~~~~
| size_t
p808.cpp:591:44: error: non-member function 'constexpr bool empty()' cannot have cv-qualifier
591 | [[nodiscard]] constexpr bool empty() const noexcept;
| ^~~~~~~~
p808.cpp:594:11: error: 'const_reference' does not name a type
594 | constexpr const_reference operator[](size_type pos) const;
| ^~~~~~~~~~~~~~~
p808.cpp:595:11: error: 'reference' does not name a type
595 | constexpr reference operator[](size_type pos);
| ^~~~~~~~~
p808.cpp:599:11: error: 'const_reference' does not name a type
599 | constexpr const_reference at(size_type pos) const;
| ^~~~~~~~~~~~~~~
p808.cpp:600:11: error: 'reference' does not name a type
600 | constexpr reference at(size_type pos);
| ^~~~~~~~~
p808.cpp:603:17: error: 'charT' does not name a type; did you mean 'char'?
603 | constexpr const charT& front() const;
| ^~~~~
| char
p808.cpp:604:11: error: 'charT' does not name a type; did you mean 'char'?
604 | constexpr charT& front();
| ^~~~~
| char
p808.cpp:607:17: error: 'charT' does not name a type; did you mean 'char'?
607 | constexpr const charT& back() const;
| ^~~~~
| char
p808.cpp:608:11: error: 'charT' does not name a type; did you mean 'char'?
608 | constexpr charT& back();
| ^~~~~
| char
p808.cpp:613:11: error: reference to 'basic_string' is ambiguous
613 | constexpr basic_string& operator+=(const basic_string& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:615:1: error: expected unqualified-id before 'return'
615 | return append(str);
| ^~~~~~
p808.cpp:617:11: error: reference to 'basic_string' is ambiguous
617 | constexpr basic_string& operator+=(const T& t);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:620:19: error: 'charT' was not declared in this scope; did you mean 'char'?
620 | basic_string_view<charT, traits> sv = t;
| ^~~~~
| char
p808.cpp:620:26: error: 'traits' was not declared in this scope
620 | basic_string_view<charT, traits> sv = t;
| ^~~~~~
p808.cpp:620:32: error: template argument 1 is invalid
620 | basic_string_view<charT, traits> sv = t;
| ^
p808.cpp:620:32: error: template argument 2 is invalid
p808.cpp:620:39: error: 't' was not declared in this scope; did you mean 'tm'?
620 | basic_string_view<charT, traits> sv = t;
| ^
| tm
p808.cpp:621:8: error: expected unqualified-id before 'return'
621 | return append(sv);
| ^~~~~~
p808.cpp:622:11: error: reference to 'basic_string' is ambiguous
622 | constexpr basic_string& operator+=(const charT* s);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:624:1: error: expected unqualified-id before 'return'
624 | return append(s); constexpr basic_string& operator+=(charT c);
| ^~~~~~
p808.cpp:624:29: error: reference to 'basic_string' is ambiguous
624 | return append(s); constexpr basic_string& operator+=(charT c);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:626:1: error: expected unqualified-id before 'return'
626 | return append(size_type{1}, c);
| ^~~~~~
p808.cpp:626:27: error: expected unqualified-id before ',' token
626 | return append(size_type{1}, c);
| ^
p808.cpp:626:30: error: expected constructor, destructor, or type conversion before ')' token
626 | return append(size_type{1}, c);
| ^
p808.cpp:627:11: error: reference to 'basic_string' is ambiguous
627 | constexpr basic_string& operator+=(initializer_list<charT> il);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:630:11: error: reference to 'basic_string' is ambiguous
630 | constexpr basic_string& append(const basic_string& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:632:1: error: expected unqualified-id before 'return'
632 | return append(str.data(), str.size());
| ^~~~~~
p808.cpp:633:11: error: reference to 'basic_string' is ambiguous
633 | constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:635:1: error: expected unqualified-id before 'return'
635 | return append(basic_string_view<charT, traits>(str).substr(pos, n));
| ^~~~~~
p808.cpp:637:13: error: reference to 'basic_string' is ambiguous
637 | constexpr basic_string& append(const T& t);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:641:19: error: 'charT' was not declared in this scope; did you mean 'char'?
641 | basic_string_view<charT, traits> sv = t;
| ^~~~~
| char
p808.cpp:641:26: error: 'traits' was not declared in this scope
641 | basic_string_view<charT, traits> sv = t;
| ^~~~~~
p808.cpp:641:32: error: template argument 1 is invalid
641 | basic_string_view<charT, traits> sv = t;
| ^
p808.cpp:641:32: error: template argument 2 is invalid
p808.cpp:641:34: error: redefinition of 'int sv'
641 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:620:34: note: 'int sv' previously defined here
620 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:641:39: error: 't' was not declared in this scope; did you mean 'tm'?
641 | basic_string_view<charT, traits> sv = t;
| ^
| tm
p808.cpp:642:3: error: expected unqualified-id before 'return'
642 | return append(sv.data(), sv.size());
| ^~~~~~
p808.cpp:644:13: error: reference to 'basic_string' is ambiguous
644 | constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:648:19: error: 'charT' was not declared in this scope; did you mean 'char'?
648 | basic_string_view<charT, traits> sv = t;
| ^~~~~
| char
p808.cpp:648:26: error: 'traits' was not declared in this scope
648 | basic_string_view<charT, traits> sv = t;
| ^~~~~~
p808.cpp:648:32: error: template argument 1 is invalid
648 | basic_string_view<charT, traits> sv = t;
| ^
p808.cpp:648:32: error: template argument 2 is invalid
p808.cpp:648:34: error: redefinition of 'int sv'
648 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:620:34: note: 'int sv' previously defined here
620 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:648:39: error: 't' was not declared in this scope; did you mean 'tm'?
648 | basic_string_view<charT, traits> sv = t;
| ^
| tm
p808.cpp:649:3: error: expected unqualified-id before 'return'
649 | return append(sv.substr(pos, n));
| ^~~~~~
p808.cpp:650:11: error: reference to 'basic_string' is ambiguous
650 | constexpr basic_string& append(const charT* s, size_type n);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:653:11: error: reference to 'basic_string' is ambiguous
653 | constexpr basic_string& append(const charT* s);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:655:1: error: expected unqualified-id before 'return'
655 | return append(s, traits::length(s));
| ^~~~~~
p808.cpp:656:11: error: reference to 'basic_string' is ambiguous
656 | constexpr basic_string& append(size_type n, charT c);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:659:13: error: reference to 'basic_string' is ambiguous
659 | constexpr basic_string& append(InputIterator first, InputIterator last);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:660:12: error: found ':' in nested-name-specifier, expected '::'
660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
| ^
| ::
p808.cpp:660:1: error: 'Constraints' does not name a type
660 | Constraints: InputIterator is a type that qualifies as an input iterator (24.2.2.1).
| ^~~~~~~~~~~
p808.cpp:663:10: error: 'container' has not been declared
663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
| ^~~~~~~~~
p808.cpp:663:19: error: expected '>' before '-' token
663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
| ^
p808.cpp:663:57: error: reference to 'basic_string' is ambiguous
663 | template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:665:1: error: expected unqualified-id before 'return'
665 | return append(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
| ^~~~~~
p808.cpp:666:11: error: reference to 'basic_string' is ambiguous
666 | constexpr basic_string& append(initializer_list<charT> il);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:668:1: error: expected unqualified-id before 'return'
668 | return append(il.begin(), il.size());
| ^~~~~~
p808.cpp:669:21: error: variable or field 'push_back' declared void
669 | constexpr void push_back(charT c);
| ^~~~~~~~~
p808.cpp:669:31: error: 'charT' was not declared in this scope; did you mean 'char'?
669 | constexpr void push_back(charT c);
| ^~~~~
| char
p808.cpp:672:11: error: reference to 'basic_string' is ambiguous
672 | constexpr basic_string& assign(const basic_string& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:674:1: error: expected unqualified-id before 'return'
674 | return *this = str;
| ^~~~~~
p808.cpp:675:11: error: reference to 'basic_string' is ambiguous
675 | constexpr basic_string& assign(basic_string&& str)
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:679:1: error: expected unqualified-id before 'return'
679 | return *this = std::move(str);
| ^~~~~~
p808.cpp:680:11: error: reference to 'basic_string' is ambiguous
680 | constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:682:1: error: expected unqualified-id before 'return'
682 | return assign(basic_string_view<charT, traits>(str).substr(pos, n));
| ^~~~~~
p808.cpp:684:13: error: reference to 'basic_string' is ambiguous
684 | constexpr basic_string& assign(const T& t);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:687:19: error: 'charT' was not declared in this scope; did you mean 'char'?
687 | basic_string_view<charT, traits> sv = t;
| ^~~~~
| char
p808.cpp:687:26: error: 'traits' was not declared in this scope
687 | basic_string_view<charT, traits> sv = t;
| ^~~~~~
p808.cpp:687:32: error: template argument 1 is invalid
687 | basic_string_view<charT, traits> sv = t;
| ^
p808.cpp:687:32: error: template argument 2 is invalid
p808.cpp:687:34: error: redefinition of 'int sv'
687 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:620:34: note: 'int sv' previously defined here
620 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:687:39: error: 't' was not declared in this scope; did you mean 'tm'?
687 | basic_string_view<charT, traits> sv = t;
| ^
| tm
p808.cpp:688:3: error: expected unqualified-id before 'return'
688 | return assign(sv.data(), sv.size());
| ^~~~~~
p808.cpp:690:13: error: reference to 'basic_string' is ambiguous
690 | constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:693:19: error: 'charT' was not declared in this scope; did you mean 'char'?
693 | basic_string_view<charT, traits> sv = t;
| ^~~~~
| char
p808.cpp:693:26: error: 'traits' was not declared in this scope
693 | basic_string_view<charT, traits> sv = t;
| ^~~~~~
p808.cpp:693:32: error: template argument 1 is invalid
693 | basic_string_view<charT, traits> sv = t;
| ^
p808.cpp:693:32: error: template argument 2 is invalid
p808.cpp:693:34: error: redefinition of 'int sv'
693 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:620:34: note: 'int sv' previously defined here
620 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:693:39: error: 't' was not declared in this scope; did you mean 'tm'?
693 | basic_string_view<charT, traits> sv = t;
| ^
| tm
p808.cpp:694:3: error: expected unqualified-id before 'return'
694 | return assign(sv.substr(pos, n));
| ^~~~~~
p808.cpp:695:11: error: reference to 'basic_string' is ambiguous
695 | constexpr basic_string& assign(const charT* s, size_type n);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:698:11: error: reference to 'basic_string' is ambiguous
698 | constexpr basic_string& assign(const charT* s);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:700:1: error: expected unqualified-id before 'return'
700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
| ^~~~~~
p808.cpp:700:48: error: reference to 'basic_string' is ambiguous
700 | return assign(s, traits::length(s)); constexpr basic_string& assign(initializer_list<charT> il);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:702:1: error: expected unqualified-id before 'return'
702 | return assign(il.begin(), il.size());
| ^~~~~~
p808.cpp:703:11: error: reference to 'basic_string' is ambiguous
703 | constexpr basic_string& assign(size_type n, charT c);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:705:10: error: expected constructor, destructor, or type conversion before ';' token
705 | clear();
| ^
p808.cpp:706:9: error: expected constructor, destructor, or type conversion before '(' token
706 | resize(n, c);
| ^
p808.cpp:707:3: error: expected unqualified-id before 'return'
707 | return *this;
| ^~~~~~
p808.cpp:709:13: error: reference to 'basic_string' is ambiguous
709 | constexpr basic_string& assign(InputIterator first, InputIterator last);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:712:1: error: expected unqualified-id before 'return'
712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
| ^~~~~~
p808.cpp:712:69: error: 'container' has not been declared
712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:712:78: error: expected '>' before '-' token
712 | return assign(basic_string(first, last, get_allocator())); template<container-compatible-range<charT> R>
| ^
p808.cpp:713:11: error: reference to 'basic_string' is ambiguous
713 | constexpr basic_string& assign_range(R&& rg);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:715:1: error: expected unqualified-id before 'return'
715 | return assign(basic_string(from_range, std::forward<R>(rg), get_- allocator()));
| ^~~~~~
p808.cpp:717:11: error: reference to 'basic_string' is ambiguous
717 | constexpr basic_string& insert(size_type pos, const basic_string& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:719:1: error: expected unqualified-id before 'return'
719 | return insert(pos, str.data(), str.size());
| ^~~~~~
p808.cpp:720:11: error: reference to 'basic_string' is ambiguous
720 | constexpr basic_string& insert(size_type pos1, const basic_string& str,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:723:1: error: expected unqualified-id before 'return'
723 | return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);
| ^~~~~~
p808.cpp:725:13: error: reference to 'basic_string' is ambiguous
725 | constexpr basic_string& insert(size_type pos, const T& t);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:728:3: error: expected unqualified-id before 'return'
728 | return insert(pos, sv.data(), sv.size());
| ^~~~~~
p808.cpp:730:13: error: reference to 'basic_string' is ambiguous
730 | constexpr basic_string& insert(size_type pos1, const T& t,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:734:3: error: expected unqualified-id before 'return'
734 | return insert(pos1, sv.substr(pos2, n));
| ^~~~~~
p808.cpp:735:11: error: reference to 'basic_string' is ambiguous
735 | constexpr basic_string& insert(size_type pos, const charT* s, size_type n);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:741:11: error: reference to 'basic_string' is ambiguous
741 | constexpr basic_string& insert(size_type pos, const charT* s);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:743:11: error: reference to 'basic_string' is ambiguous
743 | constexpr basic_string& insert(size_type pos, size_type n, charT c);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:749:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
749 | constexpr iterator insert(const_iterator p, charT c);
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:749:27: error: 'const_iterator' was not declared in this scope
749 | constexpr iterator insert(const_iterator p, charT c);
| ^~~~~~~~~~~~~~
p808.cpp:749:45: error: 'charT' was not declared in this scope; did you mean 'char'?
749 | constexpr iterator insert(const_iterator p, charT c);
| ^~~~~
| char
p808.cpp:753:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:753:27: error: 'const_iterator' was not declared in this scope
753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
| ^~~~~~~~~~~~~~
p808.cpp:753:45: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
| ^~~~~~~~~
| size_t
p808.cpp:753:58: error: 'charT' was not declared in this scope; did you mean 'char'?
753 | constexpr iterator insert(const_iterator p, size_type n, charT c);
| ^~~~~
| char
p808.cpp:758:13: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
758 | constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:758:29: error: 'const_iterator' was not declared in this scope
758 | constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
| ^~~~~~~~~~~~~~
p808.cpp:758:61: error: expected primary-expression before 'first'
758 | constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
| ^~~~~
p808.cpp:758:82: error: expected primary-expression before 'last'
758 | constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);
| ^~~~
p808.cpp:762:10: error: 'container' has not been declared
762 | template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:762:19: error: expected '>' before '-' token
762 | template<container-compatible-range<charT> R>
| ^
p808.cpp:763:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
763 | constexpr iterator insert_range(const_iterator p, R&& rg);
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:763:33: error: 'const_iterator' was not declared in this scope
763 | constexpr iterator insert_range(const_iterator p, R&& rg);
| ^~~~~~~~~~~~~~
p808.cpp:763:51: error: 'R' was not declared in this scope
763 | constexpr iterator insert_range(const_iterator p, R&& rg);
| ^
p808.cpp:763:55: error: 'rg' was not declared in this scope
763 | constexpr iterator insert_range(const_iterator p, R&& rg);
| ^~
p808.cpp:767:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:767:27: error: 'const_iterator' was not declared in this scope
767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
| ^~~~~~~~~~~~~~
p808.cpp:767:62: error: 'charT' was not declared in this scope; did you mean 'char'?
767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
| ^~~~~
| char
p808.cpp:767:67: error: template argument 1 is invalid
767 | constexpr iterator insert(const_iterator p, initializer_list<charT> il);
| ^
p808.cpp:770:11: error: reference to 'basic_string' is ambiguous
770 | constexpr basic_string& erase(size_type pos = 0, size_type n = npos);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:774:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
774 | constexpr iterator erase(const_iterator p);
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:774:26: error: 'const_iterator' was not declared in this scope
774 | constexpr iterator erase(const_iterator p);
| ^~~~~~~~~~~~~~
p808.cpp:778:11: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
778 | constexpr iterator erase(const_iterator first, const_iterator last);
| ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
p808.cpp:778:26: error: 'const_iterator' was not declared in this scope
778 | constexpr iterator erase(const_iterator first, const_iterator last);
| ^~~~~~~~~~~~~~
p808.cpp:778:48: error: 'const_iterator' was not declared in this scope
778 | constexpr iterator erase(const_iterator first, const_iterator last);
| ^~~~~~~~~~~~~~
p808.cpp:787:11: error: reference to 'basic_string' is ambiguous
787 | constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:789:1: error: expected unqualified-id before 'return'
789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~
p808.cpp:789:61: error: reference to 'basic_string' is ambiguous
789 | return replace(pos1, n1, str.data(), str.size()); constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:792:1: error: expected unqualified-id before 'return'
792 | return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));
| ^~~~~~
p808.cpp:794:13: error: reference to 'basic_string' is ambiguous
794 | constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:797:3: error: expected unqualified-id before 'return'
797 | return replace(pos1, n1, sv.data(), sv.size());
| ^~~~~~
p808.cpp:799:13: error: reference to 'basic_string' is ambiguous
799 | constexpr basic_string& replace(size_type pos1, size_type n1, const T& t,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:803:19: error: 'charT' was not declared in this scope; did you mean 'char'?
803 | basic_string_view<charT, traits> sv = t;
| ^~~~~
| char
p808.cpp:803:26: error: 'traits' was not declared in this scope
803 | basic_string_view<charT, traits> sv = t;
| ^~~~~~
p808.cpp:803:32: error: template argument 1 is invalid
803 | basic_string_view<charT, traits> sv = t;
| ^
p808.cpp:803:32: error: template argument 2 is invalid
p808.cpp:803:34: error: redefinition of 'int sv'
803 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:620:34: note: 'int sv' previously defined here
620 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:803:39: error: 't' was not declared in this scope; did you mean 'tm'?
803 | basic_string_view<charT, traits> sv = t;
| ^
| tm
p808.cpp:804:3: error: expected unqualified-id before 'return'
804 | return replace(pos1, n1, sv.substr(pos2, n2));
| ^~~~~~
p808.cpp:805:11: error: reference to 'basic_string' is ambiguous
805 | constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:810:11: error: reference to 'basic_string' is ambiguous
810 | constexpr basic_string& replace(size_type pos, size_type n, const charT* s);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:816:11: error: reference to 'basic_string' is ambiguous
816 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:818:11: error: reference to 'basic_string' is ambiguous
818 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:822:24: error: 'charT' was not declared in this scope; did you mean 'char'?
822 | basic_string_view<charT, traits> sv = t;
| ^~~~~
| char
p808.cpp:822:31: error: 'traits' was not declared in this scope
822 | basic_string_view<charT, traits> sv = t;
| ^~~~~~
p808.cpp:822:37: error: template argument 1 is invalid
822 | basic_string_view<charT, traits> sv = t;
| ^
p808.cpp:822:37: error: template argument 2 is invalid
p808.cpp:822:39: error: redefinition of 'int sv'
822 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:620:34: note: 'int sv' previously defined here
620 | basic_string_view<charT, traits> sv = t;
| ^~
p808.cpp:822:44: error: 't' was not declared in this scope; did you mean 'tm'?
822 | basic_string_view<charT, traits> sv = t;
| ^
| tm
p808.cpp:823:6: error: expected unqualified-id before 'return'
823 | return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
| ^~~~~~
p808.cpp:824:11: error: reference to 'basic_string' is ambiguous
824 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:827:11: error: reference to 'basic_string' is ambiguous
827 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:831:13: error: reference to 'basic_string' is ambiguous
831 | constexpr basic_string& replace(const_iterator i1, const_iterator i2,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:835:10: error: 'container' has not been declared
835 | template<container-compatible-range<charT> R>
| ^~~~~~~~~
p808.cpp:835:19: error: expected '>' before '-' token
835 | template<container-compatible-range<charT> R>
| ^
p808.cpp:836:11: error: reference to 'basic_string' is ambiguous
836 | constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:838:1: error: expected unqualified-id before 'return'
838 | return replace(i1, i2, basic_string(from_range, std::forward<R>(rg), get_allocator()));
| ^~~~~~
p808.cpp:839:11: error: reference to 'basic_string' is ambiguous
839 | constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:842:11: error: 'size_type' does not name a type; did you mean 'size_t'?
842 | constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
| ^~~~~~~~~
| size_t
p808.cpp:844:1: error: expected unqualified-id before 'return'
844 | return basic_string_view<charT, traits>(*this).copy(s, n, pos);
| ^~~~~~
p808.cpp:847:16: error: variable or field 'swap' declared void
847 | constexpr void swap(basic_string& s)
| ^~~~
p808.cpp:847:21: error: reference to 'basic_string' is ambiguous
847 | constexpr void swap(basic_string& s)
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:847:35: error: 's' was not declared in this scope; did you mean 'sv'?
847 | constexpr void swap(basic_string& s)
| ^
| sv
p808.cpp:852:11: error: 'size_type' does not name a type; did you mean 'size_t'?
852 | constexpr size_type F(const basic_string& str, size_type pos) const noexcept;
| ^~~~~~~~~
| size_t
p808.cpp:854:1: error: expected unqualified-id before 'return'
854 | return F (basic_string_view<charT, traits>(str), pos);
| ^~~~~~
p808.cpp:856:11: error: 'size_type' does not name a type; did you mean 'size_t'?
856 | constexpr size_type F(const charT* s, size_type pos) const;
| ^~~~~~~~~
| size_t
p808.cpp:858:1: error: expected unqualified-id before 'return'
858 | return F (basic_string_view<charT, traits>(s), pos);
| ^~~~~~
p808.cpp:860:11: error: 'size_type' does not name a type; did you mean 'size_t'?
860 | constexpr size_type F(const charT* s, size_type pos, size_type n) const;
| ^~~~~~~~~
| size_t
p808.cpp:863:11: error: 'size_type' does not name a type; did you mean 'size_t'?
863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
| ^~~~~~~~~
| size_t
p808.cpp:863:63: error: 'has' does not name a type
863 | constexpr size_type F(charT c, size_type pos) const noexcept; has effects equivalent to:
| ^~~
p808.cpp:866:11: error: 'size_type' does not name a type; did you mean 'size_t'?
866 | constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);
| ^~~~~~~~~
| size_t
p808.cpp:868:11: error: 'size_type' does not name a type; did you mean 'size_t'?
868 | constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see_below);
| ^~~~~~~~~
| size_t
p808.cpp:870:11: error: 'size_type' does not name a type; did you mean 'size_t'?
870 | constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see_below);
| ^~~~~~~~~
| size_t
p808.cpp:872:11: error: 'size_type' does not name a type; did you mean 'size_t'?
872 | constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see_below);
| ^~~~~~~~~
| size_t
p808.cpp:874:11: error: 'size_type' does not name a type; did you mean 'size_t'?
874 | constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see_below);
| ^~~~~~~~~
| size_t
p808.cpp:880:17: error: 'charT' does not name a type; did you mean 'char'?
880 | constexpr const charT* c_str() const noexcept;
| ^~~~~
| char
p808.cpp:881:17: error: 'charT' does not name a type; did you mean 'char'?
881 | constexpr const charT* data() const noexcept;
| ^~~~~
| char
p808.cpp:884:11: error: 'charT' does not name a type; did you mean 'char'?
884 | constexpr charT* data() noexcept;
| ^~~~~
| char
p808.cpp:887:38: error: 'charT' was not declared in this scope; did you mean 'char'?
887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
| ^~~~~
| char
p808.cpp:887:45: error: 'traits' was not declared in this scope
887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
| ^~~~~~
p808.cpp:887:51: error: template argument 1 is invalid
887 | constexpr operator basic_string_view<charT, traits>() const noexcept;
| ^
p808.cpp:887:51: error: template argument 2 is invalid
p808.cpp:892:11: error: 'size_type' does not name a type; did you mean 'size_t'?
892 | constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);
| ^~~~~~~~~
| size_t
p808.cpp:895:1: error: expected unqualified-id before 'return'
895 | return s.G(sv, pos);
| ^~~~~~
p808.cpp:898:11: error: reference to 'basic_string' is ambiguous
898 | constexpr basic_string substr(size_type pos = 0, size_type n = npos) const;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:902:29: error: 'T' does not name a type
902 | constexpr int compare(const T& t) const noexcept(see_below);
| ^
p808.cpp:902:50: error: 'see_below' was not declared in this scope
902 | constexpr int compare(const T& t) const noexcept(see_below);
| ^~~~~~~~~
p808.cpp:902:59: error: non-member function 'constexpr int compare(const int&)' cannot have cv-qualifier
902 | constexpr int compare(const T& t) const noexcept(see_below);
| ^
p808.cpp:908:25: error: 'template<class T> constexpr const int compare' redeclared as different kind of entity
908 | constexpr int compare(size_type pos1, size_type n1, const T& t) const;
| ^~~~~~~~~
p808.cpp:902:15: note: previous declaration 'constexpr int compare(const int&)'
902 | constexpr int compare(const T& t) const noexcept(see_below);
| ^~~~~~~
p808.cpp:908:25: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
908 | constexpr int compare(size_type pos1, size_type n1, const T& t) const;
| ^~~~~~~~~
| size_t
p808.cpp:908:41: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
908 | constexpr int compare(size_type pos1, size_type n1, const T& t) const;
| ^~~~~~~~~
| size_t
p808.cpp:908:55: error: expected primary-expression before 'const'
908 | constexpr int compare(size_type pos1, size_type n1, const T& t) const;
| ^~~~~
p808.cpp:911:1: error: expected unqualified-id before 'return'
911 | return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);
| ^~~~~~
p808.cpp:913:25: error: 'template<class T> constexpr const int compare' redeclared as different kind of entity
913 | constexpr int compare(size_type pos1, size_type n1, const T& t,
| ^~~~~~~~~
p808.cpp:902:15: note: previous declaration 'constexpr int compare(const int&)'
902 | constexpr int compare(const T& t) const noexcept(see_below);
| ^~~~~~~
p808.cpp:913:25: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
913 | constexpr int compare(size_type pos1, size_type n1, const T& t,
| ^~~~~~~~~
| size_t
p808.cpp:913:41: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
913 | constexpr int compare(size_type pos1, size_type n1, const T& t,
| ^~~~~~~~~
| size_t
p808.cpp:913:55: error: expected primary-expression before 'const'
913 | constexpr int compare(size_type pos1, size_type n1, const T& t,
| ^~~~~
p808.cpp:914:20: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
914 | size_type pos2, size_type n2 = npos) const;
| ^~~~~~~~~
| size_t
p808.cpp:914:36: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
914 | size_type pos2, size_type n2 = npos) const;
| ^~~~~~~~~
| size_t
p808.cpp:917:19: error: 'charT' was not declared in this scope; did you mean 'char'?
917 | basic_string_view<charT, traits> s = *this, sv = t;
| ^~~~~
| char
p808.cpp:917:26: error: 'traits' was not declared in this scope
917 | basic_string_view<charT, traits> s = *this, sv = t;
| ^~~~~~
p808.cpp:917:32: error: template argument 1 is invalid
917 | basic_string_view<charT, traits> s = *this, sv = t;
| ^
p808.cpp:917:32: error: template argument 2 is invalid
p808.cpp:917:39: error: invalid use of 'this' at top level
917 | basic_string_view<charT, traits> s = *this, sv = t;
| ^~~~
p808.cpp:918:8: error: expected unqualified-id before 'return'
918 | return s.substr(pos1, n1).compare(sv.substr(pos2, n2));
| ^~~~~~
p808.cpp:919:29: error: reference to 'basic_string' is ambiguous
919 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:919:54: error: non-member function 'constexpr int compare(const int&)' cannot have cv-qualifier
919 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~~
p808.cpp:919:15: error: declaration of 'constexpr int compare(const int&) noexcept' has a different exception specifier
919 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~
p808.cpp:902:15: note: from previous declaration 'constexpr int compare(const int&)'
902 | constexpr int compare(const T& t) const noexcept(see_below);
| ^~~~~~~
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:41: error: 'traits' was not declared in this scope
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
| alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:41: error: 'traits' was not declared in this scope
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
| alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:41: error: 'traits' was not declared in this scope
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
| alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:41: error: 'traits' was not declared in this scope
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
| alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:41: error: 'traits' was not declared in this scope
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
| alloca
p808.cpp:922:34: error: 'charT' was not declared in this scope; did you mean 'char'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~
| char
p808.cpp:922:41: error: 'traits' was not declared in this scope
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~
p808.cpp:922:49: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~
| alloca
p808.cpp:922:21: error: reference to 'basic_string' is ambiguous
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:922:33: error: expected ',' or '...' before '<' token
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^
p808.cpp:922:83: error: expected constructor, destructor, or type conversion before ';' token
922 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:21: error: 'charT' was not declared in this scope; did you mean 'char'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:924:28: error: 'traits' was not declared in this scope
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:924:36: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:924:8: error: reference to 'basic_string' is ambiguous
924 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:925:8: error: 'r' does not name a type
925 | r.append(rhs);
| ^
p808.cpp:926:8: error: expected unqualified-id before 'return'
926 | return r;
| ^~~~~~
p808.cpp:928:13: error: reference to 'basic_string' is ambiguous
928 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:931:26: error: 'constexpr const int compare' redeclared as different kind of entity
931 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
p808.cpp:919:15: note: previous declaration 'constexpr int compare(const int&)'
919 | constexpr int compare(const basic_string& str) const noexcept;
| ^~~~~~~
p808.cpp:931:26: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
931 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
| size_t
p808.cpp:931:42: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
931 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~~~~~
| size_t
p808.cpp:931:56: error: expected primary-expression before 'const'
931 | constexpr int compare(size_type pos1, size_type n1, const basic_string& str,
| ^~~~~
p808.cpp:932:26: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
932 | size_type pos2, size_type n2 = npos) const;
| ^~~~~~~~~
| size_t
p808.cpp:932:42: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
932 | size_type pos2, size_type n2 = npos) const;
| ^~~~~~~~~
| size_t
p808.cpp:934:1: error: expected unqualified-id before 'return'
934 | return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);
| ^~~~~~
p808.cpp:935:29: error: 'charT' does not name a type; did you mean 'char'?
935 | constexpr int compare(const charT* s) const;
| ^~~~~
| char
p808.cpp:935:39: error: non-member function 'constexpr int compare(const int*)' cannot have cv-qualifier
935 | constexpr int compare(const charT* s) const;
| ^~~~~
p808.cpp:938:23: error: 'constexpr const int compare' redeclared as different kind of entity
938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
p808.cpp:935:15: note: previous declaration 'constexpr int compare(const int*)'
935 | constexpr int compare(const charT* s) const;
| ^~~~~~~
p808.cpp:938:23: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
| size_t
p808.cpp:938:38: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
| size_t
p808.cpp:938:52: error: expected primary-expression before 'const'
938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
| ^~~~~
p808.cpp:938:68: error: 'size_type' was not declared in this scope; did you mean 'size_t'?
938 | constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;
| ^~~~~~~~~
| size_t
p808.cpp:941:46: error: 'charT' was not declared in this scope; did you mean 'char'?
941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~
| char
p808.cpp:941:53: error: 'traits' was not declared in this scope
941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~
p808.cpp:941:59: error: template argument 1 is invalid
941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^
p808.cpp:941:59: error: template argument 2 is invalid
p808.cpp:941:70: error: non-member function 'constexpr bool starts_with(int)' cannot have cv-qualifier
941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:942:28: error: 'constexpr const bool starts_with' redeclared as different kind of entity
942 | constexpr bool starts_with(charT x) const noexcept;
| ^~~~~
p808.cpp:941:16: note: previous declaration 'constexpr bool starts_with(int)'
941 | constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~~~
p808.cpp:942:28: error: 'charT' was not declared in this scope; did you mean 'char'?
942 | constexpr bool starts_with(charT x) const noexcept;
| ^~~~~
| char
p808.cpp:943:34: error: 'charT' does not name a type; did you mean 'char'?
943 | constexpr bool starts_with(const charT* x) const;
| ^~~~~
| char
p808.cpp:943:44: error: non-member function 'constexpr bool starts_with(const int*)' cannot have cv-qualifier
943 | constexpr bool starts_with(const charT* x) const;
| ^~~~~
p808.cpp:945:1: error: expected unqualified-id before 'return'
945 | return basic_string_view<charT, traits>(data(), size()).starts_with(x);
| ^~~~~~
p808.cpp:947:44: error: 'charT' was not declared in this scope; did you mean 'char'?
947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~
| char
p808.cpp:947:51: error: 'traits' was not declared in this scope
947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~
p808.cpp:947:57: error: template argument 1 is invalid
947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^
p808.cpp:947:57: error: template argument 2 is invalid
p808.cpp:947:68: error: non-member function 'constexpr bool ends_with(int)' cannot have cv-qualifier
947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:948:26: error: 'constexpr const bool ends_with' redeclared as different kind of entity
948 | constexpr bool ends_with(charT x) const noexcept;
| ^~~~~
p808.cpp:947:16: note: previous declaration 'constexpr bool ends_with(int)'
947 | constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~~
p808.cpp:948:26: error: 'charT' was not declared in this scope; did you mean 'char'?
948 | constexpr bool ends_with(charT x) const noexcept;
| ^~~~~
| char
p808.cpp:949:32: error: 'charT' does not name a type; did you mean 'char'?
949 | constexpr bool ends_with(const charT* x) const;
| ^~~~~
| char
p808.cpp:949:42: error: non-member function 'constexpr bool ends_with(const int*)' cannot have cv-qualifier
949 | constexpr bool ends_with(const charT* x) const;
| ^~~~~
p808.cpp:951:1: error: expected unqualified-id before 'return'
951 | return basic_string_view<charT, traits>(data(), size()).ends_with(x);
| ^~~~~~
p808.cpp:953:43: error: 'charT' was not declared in this scope; did you mean 'char'?
953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~
| char
p808.cpp:953:50: error: 'traits' was not declared in this scope
953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~
p808.cpp:953:56: error: template argument 1 is invalid
953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^
p808.cpp:953:56: error: template argument 2 is invalid
p808.cpp:953:67: error: non-member function 'constexpr bool contains(int)' cannot have cv-qualifier
953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:954:25: error: 'constexpr const bool contains' redeclared as different kind of entity
954 | constexpr bool contains(charT x) const noexcept;
| ^~~~~
p808.cpp:953:16: note: previous declaration 'constexpr bool contains(int)'
953 | constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;
| ^~~~~~~~
p808.cpp:954:25: error: 'charT' was not declared in this scope; did you mean 'char'?
954 | constexpr bool contains(charT x) const noexcept;
| ^~~~~
| char
p808.cpp:955:31: error: 'charT' does not name a type; did you mean 'char'?
955 | constexpr bool contains(const charT* x) const;
| ^~~~~
| char
p808.cpp:955:41: error: non-member function 'constexpr bool contains(const int*)' cannot have cv-qualifier
955 | constexpr bool contains(const charT* x) const;
| ^~~~~
p808.cpp:957:1: error: expected unqualified-id before 'return'
957 | return basic_string_view<charT, traits>(data(), size()).contains(x);
| ^~~~~~
p808.cpp:961:13: error: reference to 'basic_string' is ambiguous
961 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:965:13: error: reference to 'basic_string' is ambiguous
965 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:970:8: error: expected unqualified-id before 'return'
970 | return std::move(lhs);
| ^~~~~~
p808.cpp:971:17: error: 'charT' does not name a type; did you mean 'char'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~
| char
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~
| char
p808.cpp:971:49: error: 'traits' was not declared in this scope
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~~~~
| alloca
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~
| char
p808.cpp:971:49: error: 'traits' was not declared in this scope
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~~~~
| alloca
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~
| char
p808.cpp:971:49: error: 'traits' was not declared in this scope
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~~~~
| alloca
p808.cpp:971:42: error: 'charT' was not declared in this scope; did you mean 'char'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~
| char
p808.cpp:971:49: error: 'traits' was not declared in this scope
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~
p808.cpp:971:57: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~~~~
| alloca
p808.cpp:971:29: error: reference to 'basic_string' is ambiguous
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:971:29: error: 'basic_string' has not been declared
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^~~~~~~~~~~~
p808.cpp:971:41: error: expected ',' or '...' before '<' token
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^
p808.cpp:971:74: error: expected constructor, destructor, or type conversion before ';' token
971 | operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);
| ^
p808.cpp:973:4: error: expected unqualified-id before 'return'
973 | return std::move(rhs);
| ^~~~~~
p808.cpp:975:13: error: reference to 'basic_string' is ambiguous
975 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:979:4: error: expected unqualified-id before 'return'
979 | return std::move(lhs);
| ^~~~~~
p808.cpp:983:13: error: reference to 'basic_string' is ambiguous
983 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:987:13: error: reference to 'basic_string' is ambiguous
987 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:17: error: 'charT' was not declared in this scope; did you mean 'char'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:992:24: error: 'traits' was not declared in this scope
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:992:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:992:4: error: reference to 'basic_string' is ambiguous
992 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:993:4: error: 'r' does not name a type
993 | r.insert(0, lhs);
| ^
p808.cpp:994:4: error: expected unqualified-id before 'return'
994 | return r;
| ^~~~~~
p808.cpp:996:13: error: reference to 'basic_string' is ambiguous
996 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:17: error: 'charT' was not declared in this scope; did you mean 'char'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~
| char
p808.cpp:999:24: error: 'traits' was not declared in this scope
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~
p808.cpp:999:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~
| alloca
p808.cpp:999:4: error: reference to 'basic_string' is ambiguous
999 | basic_string<charT, traits, Allocator> r = rhs;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1000:4: error: 'r' does not name a type
1000 | r.insert(r.begin(), lhs);
| ^
p808.cpp:1001:4: error: expected unqualified-id before 'return'
1001 | return r;
| ^~~~~~
p808.cpp:1003:13: error: reference to 'basic_string' is ambiguous
1003 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1006:4: error: expected unqualified-id before 'return'
1006 | return std::move(rhs);
| ^~~~~~
p808.cpp:1008:13: error: reference to 'basic_string' is ambiguous
1008 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:17: error: 'charT' was not declared in this scope; did you mean 'char'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~
| char
p808.cpp:1011:24: error: 'traits' was not declared in this scope
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~
p808.cpp:1011:32: error: 'Allocator' was not declared in this scope; did you mean 'alloca'?
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~
| alloca
p808.cpp:1011:4: error: reference to 'basic_string' is ambiguous
1011 | basic_string<charT, traits, Allocator> r = lhs;
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1012:4: error: 'r' does not name a type
1012 | r.push_back(rhs);
| ^
p808.cpp:1013:4: error: expected unqualified-id before 'return'
1013 | return r;
| ^~~~~~
p808.cpp:1014:11: error: 'see' does not name a type
1014 | constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);
| ^~~
p808.cpp:1016:1: error: expected unqualified-id before 'return'
1016 | return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);
| ^~~~~~
p808.cpp:1018:13: error: reference to 'basic_string' is ambiguous
1018 | constexpr basic_string<charT, traits, Allocator>
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1021:8: error: expected unqualified-id before 'return'
1021 | return std::move(lhs);
| ^~~~~~
p808.cpp:1025:22: error: reference to 'basic_string' is ambiguous
1025 | operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1025:34: error: expected ',' or '...' before '<' token
1025 | operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^
p808.cpp:1025:5: error: 'constexpr bool operator==(int)' must have an argument of class or enumerated type
1025 | operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~
p808.cpp:1028:35: error: reference to 'basic_string' is ambiguous
1028 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1028:47: error: expected ',' or '...' before '<' token
1028 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^
p808.cpp:1028:18: error: 'constexpr bool operator==(int)' must have an argument of class or enumerated type
1028 | constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~
p808.cpp:1031:11: error: 'see_below' does not name a type
1031 | constexpr see_below operator<=>(const basic_string<charT, traits, Allocator>& lhs,
| ^~~~~~~~~
p808.cpp:1035:10: error: declaration of template parameter 'charT' shadows template parameter
1035 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1033:10: note: template parameter 'charT' declared here
1033 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1035:23: error: declaration of template parameter 'traits' shadows template parameter
1035 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1033:23: note: template parameter 'traits' declared here
1033 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1035:37: error: declaration of template parameter 'Allocator' shadows template parameter
1035 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1033:37: note: template parameter 'Allocator' declared here
1033 | template<class charT, class traits, class Allocator>
| ^~~~~
p808.cpp:1037:5: error: too many template-parameter-lists
1037 | swap(basic_string<charT, traits, Allocator>& lhs,
| ^~~~
p808.cpp:1044:46: error: reference to 'basic_string' is ambiguous
1044 | operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1044:46: error: 'basic_string' has not been declared
1044 | operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:1044:58: error: expected ',' or '...' before '<' token
1044 | operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:1054:22: error: reference to 'basic_string' is ambiguous
1054 | const basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1054:34: error: expected ',' or '...' before '<' token
1054 | const basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:1059:13: error: reference to 'basic_string' is ambiguous
1059 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1059:13: error: 'basic_string' has not been declared
1059 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
p808.cpp:1059:25: error: expected ',' or '...' before '<' token
1059 | basic_string<charT, traits, Allocator>& str,
| ^
p808.cpp:1064:13: error: reference to 'basic_string' is ambiguous
1064 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1064:13: error: 'basic_string' has not been declared
1064 | basic_string<charT, traits, Allocator>& str,
| ^~~~~~~~~~~~
p808.cpp:1064:25: error: expected ',' or '...' before '<' token
1064 | basic_string<charT, traits, Allocator>& str,
| ^
p808.cpp:1075:13: error: reference to 'basic_string' is ambiguous
1075 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1075:13: error: 'basic_string' has not been declared
1075 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:1075:25: error: expected ',' or '...' before '<' token
1075 | basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:1079:9: error: reference to 'basic_string' is ambiguous
1079 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:22:13: note: candidates are: 'template<class charT, class traits, class Allocator> class std::basic_string'
22 | class basic_string;
| ^~~~~~~~~~~~
/usr/local/include/c++/12.1.0/bits/stringfwd.h:72:11: note: 'template<class _CharT, class _Traits, class _Alloc> class std::__cxx11::basic_string'
72 | class basic_string;
| ^~~~~~~~~~~~
p808.cpp:494:11: note: 'constexpr int basic_string(const int&, const int&)'
494 | constexpr basic_string(const basic_string& str, const Allocator& alloc);
| ^~~~~~~~~~~~
p808.cpp:487:13: note: 'template<class InputIterator> constexpr int basic_string(InputIterator, InputIterator, const int&)'
487 | constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:478:11: note: 'constexpr int basic_string(const int*, const int&)'
478 | constexpr basic_string(const charT* s, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:474:11: note: 'constexpr int basic_string(const int*, int, const int&)'
474 | constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:470:22: note: 'template<class T> constexpr int basic_string(const T&, const int&)'
470 | constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:466:13: note: 'template<class T> constexpr int basic_string(const T&, int, int, const int&)'
466 | constexpr basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator());
| ^~~~~~~~~~~~
p808.cpp:462:11: note: 'constexpr int basic_string(const int&, int, int, const int&)'
462 | constexpr basic_string(const basic_string& str, size_type pos, size_type n,
| ^~~~~~~~~~~~
p808.cpp:460:11: note: 'constexpr int basic_string(const int&, int, const int&)'
460 | constexpr basic_string(const basic_string& str, size_type pos,
| ^~~~~~~~~~~~
p808.cpp:456:20: note: 'constexpr int basic_string(const int&)'
456 | constexpr explicit basic_string(const Allocator& a) noexcept;
| ^~~~~~~~~~~~
p808.cpp:1079:9: error: 'basic_string' has not been declared
1079 | basic_string<charT, traits, Allocator>& str);
| ^~~~~~~~~~~~
p808.cpp:1079:21: error: expected ',' or '...' before '<' token
1079 | basic_string<charT, traits, Allocator>& str);
| ^
p808.cpp:1083:22: error: expected nested-name-specifier before 'basic_string'
1083 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~~~~
p808.cpp:1083:34: error: expected initializer before '<' token
1083 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^
p808.cpp:1086:21: error: 'c' was not declared in this scope
1086 | auto it = remove(c.begin(), c.end(), value);
| ^
p808.cpp:1086:32: error: 'c' was not declared in this scope
1086 | auto it = remove(c.begin(), c.end(), value);
| ^
p808.cpp:1086:41: error: 'value' was not declared in this scope
1086 | auto it = remove(c.begin(), c.end(), value);
| ^~~~~
p808.cpp:1087:26: error: 'c' was not declared in this scope
1087 | auto r = distance(it, c.end());
| ^
p808.cpp:1088:4: error: 'c' does not name a type
1088 | c.erase(it, c.end());
| ^
p808.cpp:1089:4: error: expected unqualified-id before 'return'
1089 | return r;
| ^~~~~~
p808.cpp:1091:22: error: expected nested-name-specifier before 'basic_string'
1091 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^~~~~~~~~~~~
p808.cpp:1091:34: error: expected initializer before '<' token
1091 | constexpr typename basic_string<charT, traits, Allocator>::size_type
| ^
p808.cpp:1094:24: error: 'c' was not declared in this scope
1094 | auto it = remove_if(c.begin(), c.end(), pred);
| ^
p808.cpp:1094:35: error: 'c' was not declared in this scope
1094 | auto it = remove_if(c.begin(), c.end(), pred);
| ^
p808.cpp:1094:44: error: 'pred' was not declared in this scope; did you mean 'pread'?
1094 | auto it = remove_if(c.begin(), c.end(), pred);
| ^~~~
| pread
p808.cpp:1094:14: error: 'remove_if' was not declared in this scope; did you mean 'remove'?
1094 | auto it = remove_if(c.begin(), c.end(), pred);
| ^~~~~~~~~
| remove
p808.cpp:1095:26: error: 'c' was not declared in this scope
1095 | auto r = distance(it, c.end());
| ^
p808.cpp:1096:4: error: 'c' does not name a type
1096 | c.erase(it, c.end());
| ^
p808.cpp:1097:4: error: expected unqualified-id before 'return'
1097 | return r;
| ^~~~~~
p808.cpp:1150:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1150 | template<> struct hash<string>;
| ^~~~~~~~~~~~
p808.cpp:1151:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1151 | template<> struct hash<u8string>;
| ^~~~~~~~~~~~~~
p808.cpp:1152:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1152 | template<> struct hash<u16string>;
| ^~~~~~~~~~~~~~~
p808.cpp:1153:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1153 | template<> struct hash<u32string>;
| ^~~~~~~~~~~~~~~
p808.cpp:1154:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1154 | template<> struct hash<wstring>;
| ^~~~~~~~~~~~~
p808.cpp:1155:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1155 | template<> struct hash<pmr::string>;
| ^~~~~~~~~~~~~~~~~
p808.cpp:1156:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1156 | template<> struct hash<pmr::u8string>;
| ^~~~~~~~~~~~~~~~~~~
p808.cpp:1157:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1157 | template<> struct hash<pmr::u16string>;
| ^~~~~~~~~~~~~~~~~~~~
p808.cpp:1158:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1158 | template<> struct hash<pmr::u32string>;
| ^~~~~~~~~~~~~~~~~~~~
p808.cpp:1159:19: error: explicit specialization of 'template<class _Tp> struct std::hash' outside its namespace must use a nested-name-specifier [-fpermissive]
1159 | template<> struct hash<pmr::wstring>;
| ^~~~~~~~~~~~~~~~~~
p808.cpp:1161:18: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
1161 | constexpr string operator""s(const char* str, size_t len);
| ^~~~~~~~
p808.cpp:1163:20: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
1163 | constexpr u8string operator""s(const char8_t* str, size_t len);
| ^~~~~~~~
p808.cpp:1165:21: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
1165 | constexpr u16string operator""s(const char16_t* str, size_t len);
| ^~~~~~~~
p808.cpp:1167:21: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
1167 | constexpr u32string operator""s(const char32_t* str, size_t len);
| ^~~~~~~~
p808.cpp:1169:19: warning: literal operator suffixes not preceded by '_' are reserved for future standardization [-Wliteral-suffix]
1169 | constexpr wstring operator""s(const wchar_t* str, size_t len);
| ^~~~~~~~
p808.cpp:774:20: warning: 'erase' defined but not used [-Wunused-variable]
774 | constexpr iterator erase(const_iterator p);
| ^~~~~
p808.cpp:749:20: warning: 'insert' defined but not used [-Wunused-variable]
749 | constexpr iterator insert(const_iterator p, charT c);
| ^~~~~~
検討事項(agenda)
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。
参考資料(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/kaizen_nagoya/items/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 初稿 20220804