2411C++,学习C++提示2

C++26包索引

template<auto N> consteval auto nth(auto... ts) { return ts...[N]; }
static_assert(1 == nth<0>(1, 2, 3));
static_assert(2 == nth<1>(1, 2, 3));
static_assert(3 == nth<2>(1, 2, 3));

C++26包索引的第1和最后

template <size_t Index, class T0, class... Types>
constexpr decltype(auto) nth(T0&& p0, Types&&... pack) noexcept
{if constexpr (0 == Index)return std::forward<T0>(p0);elsereturn nth<Index-1>(std::forward<Types>(pack)...);
}consteval auto first(auto... ts) {return nth<0>(ts...);
}consteval auto last(auto... ts) {return nth<sizeof...(ts) - 1>(ts...);
}
static_assert(1 == first(1, 2, 3));
static_assert(3 == last(1, 2, 3));

平映

int main() {stdext::flat_map<int, int> fm{};fm.emplace(1, 2);fm.emplace(3, 4);assert(fm.size() == 2);assert(fm[1]==2 and fm[2]==3);
}

无唯一地址

template<class> struct box{};struct unique {[[no_unique_address]] box<int> _1;[[no_unique_address]] box<bool> _2;
};
static_assert(sizeof(unique)==1);struct no_unique {[[no_unique_address]] box<int> _1;[[no_unique_address]] box<int> _2;
};static_assert(sizeof(no_unique)!=1);

是独特的

template <class T> struct box {};template <class... Ts> struct unique;template <>
struct unique<> {};template <class T, class ...Args>
struct unique<T, Args ...> : public unique<Args ...> {constexpr explicit unique(T&& t, Args&&... args) : unique<Args...>(args ...) {}[[no_unique_address]] box<T> t_;
};template <class... Ts>
constexpr auto is_unique = (sizeof(unique<Ts...>) == 1);

template <typename T>
struct empty_wrap { };template <typename T, typename = decltype([]() {})>
struct unique_empty_box {[[no_unique_address]] empty_wrap<T> e;
};template <typename... Ts>
struct empty_type_pack : public unique_empty_box<Ts>... { };template <typename... Ts>
constexpr bool is_unique = sizeof(empty_type_pack<Ts...>) == 1;

template <class>
struct box {box() = delete;
};
template <class... Ts>
struct S;
template <>
struct S<> {};
template <class T, class... Ts>
struct S<T, Ts...> : S<Ts...> {[[no_unique_address]] box<T> _;
};template <class... Ts>
constexpr auto is_unique = sizeof(S<Ts...>) == 1;

线本常初化

extern constinit thread_local int var;
auto fn() { return var; }

区间串视

constexpr std::string text = "Hello, World!";
constexpr std::string_view view(text.c_str() + 7, 5);
static_assert(view == std::string_view{"World"});

显式串视缓冲

template<auto N>
struct buffer; // TODOconstexpr buffer<42> b;
static_assert(42 == std::string_view{b}.size());
static_assert(&b.data[0] == std::string_view{b}.begin());
static_assert(&b.data[42] == std::string_view{b}.end());

template <auto N>
struct buffer {constexpr buffer() {}constexpr char const* begin() const { return data; }constexpr char const* end() const { return data + N; }constexpr operator std::basic_string_view<char>() const {return std::basic_string_view<char>(begin(), end());}char data[N]{};
};

标::访问

template<class... Ts>
struct inc {std::variant<Ts...> v{};auto operator++() {std::visit([&](auto& v) { ++v; }, v);}template<class T>operator T() const {T result{};std::visit(overloaded{[&](T v) { result = v; },[](auto&&) {}}, v);return result;}
};auto visit(std::int16_t size, std::int32_t iterations) {auto it = inc<std::int8_t, std::int16_t, std::int32_t>{size};for (auto i = 0; i < iterations; ++i, ++it);return std::int16_t(it);
}

实现:

template<class F, class V, class R, std::size_t N, std::size_t Size>
constexpr auto visit_impl([[maybe_unused]] F&& f, [[maybe_unused]] V&& v) -> R {if constexpr (N < Size) {switch (v.index()) {default:return visit_impl<F, V, R, N+1, Size>(std::forward<F>(f), std::forward<V>(v));case N:return std::forward<F>(f)(std::get<N>(std::forward<V>(v)));}} else {__builtin_unreachable();}
}template<class F, class V, template<class...> class T, class... Ts>
auto result_type(T<Ts...>&&) ->std::common_type_t<decltype(std::declval<F>()(std::get<Ts>(std::declval<V>())))...>;template<class F, class V, template<class...> class T, class... Ts>
auto result_type(T<std::monostate, Ts...>&&) ->std::common_type_t<decltype(std::declval<F>()(std::get<Ts>(std::declval<V>())))...>;template<class F, class V>
constexpr decltype(auto) visit(F&& f, V&& v) {using variant_t = std::remove_const_t<std::remove_reference_t<V>>;constexpr auto size = std::variant_size_v<variant_t>;static_assert(size > 0, "Empty variant is not supported!");using result_t = decltype(result_type<F, V>(std::declval<variant_t>()));return visit_impl<F, V, result_t, 0u, size>(std::forward<F>(f), std::forward<V>(v));
}

C++26可变友

class FriendClass;class MyClass {friend class FriendClass;public:constexpr MyClass(int data) : privateData(data) {}private:int privateData;
};struct FriendClass {constexpr auto accessPrivateData(const MyClass& obj) const {return obj.privateData;}
};constexpr MyClass obj{42};
constexpr FriendClass friend_obj{};
static_assert(42 == friend_obj.accessPrivateData(obj));

扩展可变友类

template <class... Ts>
class MyClass {friend Ts...;public:constexpr explicit MyClass(int data) : privateData(data) {}private:int privateData{};
};template<auto>
struct FriendClass {constexpr auto accessPrivateData(const auto& obj) const {return obj.privateData;}
};constexpr MyClass<FriendClass<0>, FriendClass<1>, FriendClass<2>> obj{42};
constexpr FriendClass<0> friend_obj0{};
constexpr FriendClass<1> friend_obj1{};
constexpr FriendClass<2> friend_obj2{};static_assert(42 == friend_obj0.accessPrivateData(obj));
static_assert(42 == friend_obj1.accessPrivateData(obj));
static_assert(42 == friend_obj2.accessPrivateData(obj));

原位向量

int main() {std::inplace_vector<int, 2> v{};assert(v.empty());v.push_back(1);assert(1 == v.size());v.push_back(2);assert(2 == v.size());v.push_back(3); // throws
}

实现

template <class T, auto Size>
struct inplace_vector {constexpr void push_back(T value) { data_[index_++] = value; }constexpr const auto& operator[](auto index) const { return data_[index]; }constexpr auto size() const { return index_; }constexpr auto clear() { index_ = {}; }private:std::array<T, Size> data_{};std::size_t index_{};
};

template <class T, auto Size>
class inplace_vector {public:constexpr T& push_back(const T& t) {if (size_ == Size) {throw std::bad_alloc();}return arr_[size_++].emplace(t);}constexpr std::size_t size() const { return size_; }constexpr T& operator[](std::size_t idx) { return *arr_[idx]; }private:std::array<std::optional<T>, Size> arr_;std::size_t size_ = 0;
};

聚集是命名元组

#include <tuple>struct foo {int i{};bool b{};float f{};
};constexpr auto f  = foo{.i = 42, .b = true, .f = 4.2f};
static_assert(42 == std::get<0>(f) and std::get<1>(f) and 4.2f == std::get<2>(f));

聚集的取

template <typename T, std::size_t I, typename = void>
struct has_get : std::false_type {};
template <typename T, std::size_t I>
struct has_get<T, I, std::void_t<decltype(std::get<I>(std::declval<T>()))>>: std::true_type {};namespace std {
template <typename T>
concept DoesNotHaveGetConcept = requires(T t) { !has_get<T, 0>::value; };
namespace mp = boost::mp;
template <std::size_t I>
constexpr auto get(DoesNotHaveGetConcept auto s) {return std::get<I>(mp::reflection::to_tuple(s));
}
}  // namespace std

C++26常式从`空*`转换

struct foo{};
constexpr auto f1 = foo{};
constexpr auto ptr = static_cast<const void*>(&f1);
constexpr auto f2 = static_cast<const foo*>(ptr); // okay in C++26

常式擦除

struct Animal_View {const void *animal;std::string_view (*speak_func)(const void *animal);template <class Animal>Animal_View(const Animal &animal): animal(&animal), speak_func([](const void *animal) {return static_cast<const Animal *>(animal)->speak();}) {}constexpr std::string_view speak() { return speak_func(animal); }
};

struct Sheep {constexpr std::string_view speak() const noexcept { return "Baaaaaa"; }
};struct Cow {constexpr std::string_view speak() const noexcept { return "Mooo"; }
};// TODO Animal_Viewstd::string_view do_speak(Animal_View av) { return av.speak(); }int main() {using namespace boost::ut;"constexpr cast from void*"_test = [] {should("say Mooo for cow") = [] {constexpr Cow cow;auto result = do_speak(cow);expect(std::string_view{"Mooo"} == result);};should("say Baaaaaa for sheep") = [] {constexpr Sheep sheep;auto result = do_speak(sheep);expect(std::string_view{"Baaaaaa"} == result);};};
}

成员访问

// C++23
std::visit(overload{[](int i){ std::print("i={}\n", i); },[](std::string s){ std::print("s={:?}\n", s); }
}, value);// C++26
value.visit(overload{[](int i){ std::print("i={}\n", i); },[](std::string s){ std::print("s={:?}\n", s); }
});

变量成员访问

// TODO: variantint main() {constexpr variant<int, double, float> value = 42;static_assert(42 == value.visit(overload{[](int i) { return i; },[](auto)  { return 0; }}));
}

template <class... Ts>
struct overload : Ts... {using Ts::operator()...;
};
template <class... Ts>
overload(Ts...) -> overload<Ts...>;template <class... Ts>
struct variant : std::variant<Ts...> {using std::variant<Ts...>::variant;constexpr auto visit(auto f) const { return std::visit(f, *this); }
};