std::experimental::nonesuch

C++

Language

Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

Technical specifications

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals 2 TS)

Extensions for parallelism (parallelism TS)

Extensions for parallelism 2 (parallelism TS v2)

Extensions for concurrency (concurrency TS)

Concepts (concepts TS)

Ranges (ranges TS)

Special mathematical functions (special math TR)

Library fundamentals v2

experimental::propagate_const

experimental::not_fn

experimental::observer_ptr

experimental::make_array

experimental::to_array

experimental::ostream_joiner

experimental::gcd

experimental::lcm

experimental::source_location

experimental::randint

detection idiom

uniform container erasure

logical operator type traits

Defined in header <experimental/type_traits>
struct nonesuch { nonesuch() = delete; ~nonesuch() = delete; nonesuch(nonesuch const&) = delete; void operator=(nonesuch const&) = delete; };		(library fundamentals TS v2)

std::experimental::nonesuch is a class type used by std::experimental::detected_t to indicate detection failure.

Notes

nonesuch cannot be constructed, destroyed, or copied in the usual way. However, it is an aggregate and therefore can be constructed (presumably unintentionally) via aggregate initialization in contexts where the destructor's availability is not an issue, such as a new-expression: new std::experimental::nonesuch{}.

Additionally, for overload resolution purposes, an implicit conversion sequence can be formed from {} (an empty braced-init-list) to nonesuch. This can cause surprising ambiguities:

struct such {};
void f(const such&);
void f(const std::experimental::nonesuch&);
f({}); // ambiguous