302.md

<details open><summary>Info</summary><p>

* **Did you now that with concepts you can override a type?**

  * https://eel.is/c++draft/temp.concept#def:concept

</p></details><details open><summary>Example</summary><p>

```cpp
template<auto N> struct foo  {
  static constexpr auto value = N;
};
static_assert(42 == foo<42>::value);

template<auto N>
  requires true // override -> more specialized
struct foo<N> {
  static constexpr auto value = 0;
};
static_assert(42 == foo<42>::value); // memoized
static_assert(0 == foo<43>::value);
```

> https://godbolt.org/z/hPcsKG4an

</p></details><details open><summary>Puzzle</summary><p>

* **Can you override std::shared_ptr to avoid thred-safe guards?**

```cpp
#include <memory>

// TODO override shared_ptr with std::__shared_ptr<int, __gnu_cxx::_S_single> which is is not thread-safe
// NOTE overriding STL is UB
// Alternative - boost::local_shared_ptr

#include <type_traits>
static_assert(std::is_base_of_v<std::__shared_ptr<int, __gnu_cxx::_S_single>, std::shared_ptr<int>>);
```

> https://godbolt.org/z/7axP5or3q

</p></details><details><summary>Solutions</summary><p>

```cpp
namespace std {
    template<class T> requires ::std::is_same_v<T, int>
    class shared_ptr<T> : public __shared_ptr<int, __gnu_cxx::_S_single> {};
}
```

 > https://godbolt.org/z/Mhj1M7Yec

```cpp
namespace std {
template <class T>
    requires std::is_integral_v<T>
class shared_ptr<T> : public __shared_ptr<int, __gnu_cxx::_S_single> {};
}  // namespace std
```

> https://godbolt.org/z/sa9a937of

```cpp
namespace boost{
    template<typename N> requires std::is_same_v<int,N>
    struct shared_ptr<N> : std::__shared_ptr<N, __gnu_cxx::_S_single> {
    };
}

static_assert(std::is_base_of_v<std::__shared_ptr<int, __gnu_cxx::_S_single>, boost::shared_ptr<int>>);
```

> https://godbolt.org/z/acWKbG4fG

```cpp
namespace std{
    template<typename N> requires is_same_v<int,N>
    struct shared_ptr<N> : std::__shared_ptr<N, __gnu_cxx::_S_single> {
    };
}

static_assert(std::is_base_of_v<std::__shared_ptr<int, __gnu_cxx::_S_single>, std::shared_ptr<int>>);
```

> https://godbolt.org/z/z7YznT45n


```cpp
template <class T>
concept integral = std::is_integral_v<T>;

namespace std{
    template<integral T>
    class shared_ptr<T> : public std::__shared_ptr<T, __gnu_cxx::_S_single>{
    };
}

#include <type_traits>
static_assert(std::is_base_of_v<std::__shared_ptr<int, __gnu_cxx::_S_single>, std::shared_ptr<int>>);
```

> https://godbolt.org/z/PP6KEczMb

```cpp
template<typename T>
requires true
class std::shared_ptr<T> : std::__shared_ptr<T, __gnu_cxx::_S_single> {
};

#include <type_traits>
static_assert(std::is_base_of_v<std::__shared_ptr<int, __gnu_cxx::_S_single>, std::shared_ptr<int>>);
```

> https://godbolt.org/z/rrr8GP3qe