std::pointer_tag_pair(C++29)

namespace std {
  template <class Ptr,
            unsigned int BitsRequested = bits-available<element-of<Ptr>>,
            class TagT = unsigned int>
  class pointer_tag_pair;
}

// 1ビットのタグで、所有権の有無を印付けする例
enum class ownership : unsigned { reference, owning };
std::pointer_tag_pair<int*, 1, ownership> p{ptr, ownership::owning};
static_assert(sizeof(p) == sizeof(int*));

namespace std {
  // 型Tのアライメントからタグ付けに使用できるビット数
  template <class T>
  constexpr unsigned int bits-available = pointer_bits_available(alignof(T)); // 説明専用

  // ポインタ型Uの指す先の型
  template <class U>
  using element-of = pointer_traits<U>::element_type; // 説明専用

  // タグ値vの表現に必要なビット数。
  // vが列挙型ならbit_width(to_underlying(v))、そうでなければbit_width(v)
  template <class T>
  constexpr unsigned int tag-bit-width(T v) noexcept; // 説明専用
}

#include <memory>
#include <iostream>

int main()
{
  int x = 42;

  // intのアライメントは通常4なので、下位2ビットをタグに使える
  std::pointer_tag_pair<int*, 2> p{&x, 0b10u};
  static_assert(sizeof(p) == sizeof(int*));

  std::cout << *p.pointer() << std::endl;
  std::cout << p.tag() << std::endl;
}

#include <memory>
#include <iostream>
#include <cstdint>
#include <bit>

int main()
{
  int x = 42;
  std::pointer_tag_pair<int*, 2> p{&x, 0b10u};

  // タグを埋め込んだままの生のポインタ値を整数として観察する。
  // 埋め込みの表現は未規定だが、多くの実装ではアライメントによって
  // 常に0になる下位ビットへ格納される
  auto tagged = std::bit_cast<std::uintptr_t>(p.tagged_pointer());
  auto addr = std::bit_cast<std::uintptr_t>(&x);

  std::cout << (tagged & 0b11u) << std::endl;         // 下位2ビット : タグの値
  std::cout << ((tagged & ~std::uintptr_t{0b11u}) == addr) << std::endl; // 残り : 元のアドレス
}

#include <memory>
#include <iostream>

// 「所有するポインタ」と「参照するだけのポインタ」の両方になれる型。
// フラグを別メンバに持つ実装と違い、サイズはポインタ1個分で済む
template <typename T>
class maybe_owning_ptr {
  enum class ownership : unsigned int { reference, owning };

  std::pointer_tag_pair<T*, 1, ownership> ptr_;

public:
  explicit maybe_owning_ptr(T*&& p) noexcept : ptr_{p, ownership::owning} {}
  explicit maybe_owning_ptr(T& r) noexcept : ptr_{&r, ownership::reference} {}

  T& operator*() const noexcept { return *ptr_.pointer(); }

  ~maybe_owning_ptr() {
    if (ptr_.tag() == ownership::owning) {
      delete ptr_.pointer();
    }
  }
};
static_assert(sizeof(maybe_owning_ptr<int>) == sizeof(int*));

int main()
{
  int local = 1;
  maybe_owning_ptr<int> ref{local};          // 参照するだけ。deleteされない
  maybe_owning_ptr<int> own{new int(2)};     // 所有する。デストラクタでdeleteされる

  std::cout << *ref << *own << std::endl;
}

#include <memory>
#include <iostream>

// 二分木のノードへのポインタの下位1ビットに「葉かどうか」を埋め込む。
// ノード側に種別のメンバを持つ必要がなく、葉には子配列も不要になる
struct Leaf {
  int value;
};
struct Inner;
using node_ptr = std::pointer_tag_pair<void*, 1, bool>; // タグ : 葉ならtrue
struct Inner {
  node_ptr children[2];
};

int sum(node_ptr node)
{
  if (node.tag()) {
    return static_cast<Leaf*>(node.pointer())->value;
  }
  auto* inner = static_cast<Inner*>(node.pointer());
  return sum(inner->children[0]) + sum(inner->children[1]);
}

int main()
{
  Leaf a{1}, b{2}, c{3};
  Inner left{{node_ptr{&a, true}, node_ptr{&b, true}}};
  Inner root{{node_ptr{&left, false}, node_ptr{&c, true}}};

  std::cout << sum(node_ptr{&root, false}) << std::endl;
}