Special Interest Group on C++

@sigcpp.bsky.social

124 Followers 56 Following

Teaching, learning, and practicing contemporary C++ #cpp #cplusplus #education #teaching #EduSky Moderated by @smurthys.bsky.social

Syntax-highlighted C++ code in a dark theme: template<class T, T v> struct integral_constant { static constexpr T value = v; using value_type = T; using type = integral_constant; constexpr operator value_type() const noexcept { return value; } constexpr value_type operator()() const noexcept { return value; } }; using true_type = integral_constant<bool, true>; using false_type = integral_constant<bool, false>; template<class T, class U> struct is_same : false_type {}; template<class T> struct is_same<T, T> : true_type {}; template<class T, class U> inline constexpr bool is_same_v = is_same<T, U>::value; template<class T, class U> concept SameHelper = is_same_v<T, U>; template<class T, class U> concept same_as = SameHelper<T, U> && SameHelper<U, T>;
Syntax-highlighted C++ code in a dark theme: struct S1 { int i_, j_, k_; S1() : S1(1) {} //start delegation chain S1(int i) : S1(i, 2) {} S1(int i, int j) : S1(i, j, 3) {} S1(int i, int j, int k) : i_(i), j_(j), k_(k) {} };
Syntax-highlighted C++ code in a dark theme: int i; //int is a type, i is of type int struct S { } s; //S is a type, s is of type S
White text on black: And so it was, that the C-style cast, the most powerful of all the casts, with the easiest and most tempting syntax, who gleefully casts away your const, who insidiously breaks your pointer casts, and who laughs at the light of private inheritance, was therefore the scariest cast of all.
C++ code in a dark theme: auto n_var = SIZE_MAX; auto p1 = new char[n_var]; //runtime error
Syntax-highlighted C++ code in a dark theme: //source string to reverse const std::string s1 = "hello"; // Approach 1: new string cannot be const std::string s2(s1); std::reverse(s2.begin(), s2.end()); // Approach 2: new string can even be const const std::string s3(s1.rbegin(), s1.rend());
Syntax-highlighted C++ code: template <std::integral I, typename E> requires std::is_enum_v<E> constexpr I to_integer(E e) noexcept { return I(e); } template <typename E> requires std::is_enum_v<E> constexpr auto to_integer(E e) noexcept { return std::underlying_type_t<E>(e); }