typedef signed char        int8_t;
typedef short              int16_t;
typedef int                int32_t;
typedef long long          int64_t;
typedef unsigned char      uint8_t;
typedef unsigned short     uint16_t;
typedef unsigned int       uint32_t;
typedef unsigned long long uint64_t;

std::uint64_t v1; unsigned long long v2;
stream << OutputWrapper1(v1) << OutputWrapper2(v2);

M>typedef signed char        int8_t;
M>typedef short              int16_t;
M>typedef int                int32_t;
M>typedef long long          int64_t;
M>typedef unsigned char      uint8_t;
M>typedef unsigned short     uint16_t;
M>typedef unsigned int       uint32_t;
M>typedef unsigned long long uint64_t;
M>

struct S {
    S& operator<<(char              ) { std::cout<<"char              "<<std::endl; return *this; }
    S& operator<<(signed char       ) { std::cout<<"signed char       "<<std::endl; return *this; }
    S& operator<<(unsigned char     ) { std::cout<<"unsigned char     "<<std::endl; return *this; }
    S& operator<<(signed short      ) { std::cout<<"signed short      "<<std::endl; return *this; }
    S& operator<<(signed int        ) { std::cout<<"signed int        "<<std::endl; return *this; }
    S& operator<<(signed long       ) { std::cout<<"signed long       "<<std::endl; return *this; }
    S& operator<<(signed long long  ) { std::cout<<"signed long long  "<<std::endl; return *this; }
    S& operator<<(unsigned short    ) { std::cout<<"unsigned short    "<<std::endl; return *this; }
    S& operator<<(unsigned int      ) { std::cout<<"unsigned int      "<<std::endl; return *this; }
    S& operator<<(unsigned long     ) { std::cout<<"unsigned long     "<<std::endl; return *this; }
    S& operator<<(unsigned long long) { std::cout<<"unsigned long long"<<std::endl; return *this; }

C>>struct S {
C>>    S& operator<<(char              ) { std::cout<<"char              "<<std::endl; return *this; }
C>>    S& operator<<(signed char       ) { std::cout<<"signed char       "<<std::endl; return *this; }
C>>    S& operator<<(unsigned char     ) { std::cout<<"unsigned char     "<<std::endl; return *this; }
C>>    S& operator<<(signed short      ) { std::cout<<"signed short      "<<std::endl; return *this; }
C>>    S& operator<<(signed int        ) { std::cout<<"signed int        "<<std::endl; return *this; }
C>>    S& operator<<(signed long       ) { std::cout<<"signed long       "<<std::endl; return *this; }
C>>    S& operator<<(signed long long  ) { std::cout<<"signed long long  "<<std::endl; return *this; }
C>>    S& operator<<(unsigned short    ) { std::cout<<"unsigned short    "<<std::endl; return *this; }
C>>    S& operator<<(unsigned int      ) { std::cout<<"unsigned int      "<<std::endl; return *this; }
C>>    S& operator<<(unsigned long     ) { std::cout<<"unsigned long     "<<std::endl; return *this; }
C>>    S& operator<<(unsigned long long) { std::cout<<"unsigned long long"<<std::endl; return *this; }
C>>

#include <iostream>
#include <concepts>
#include <climits>

template <typename T>
concept Integer = std::integral<T>;

template <typename T>
concept SignedInteger = std::signed_integral<T>;

template <typename T>
concept UnsignedInteger = std::unsigned_integral<T>;

template <typename T, size_t size>
concept SignedIntegerOfSize = SignedInteger<T> and sizeof(T) * CHAR_BIT == size;

template <typename T, size_t size>
concept UnsignedIntegerOfSize = UnsignedInteger<T> and sizeof(T) * CHAR_BIT == size;

void foo(Integer auto value) {
   std::cout << "Integer: " << value << std::endl;
}

void foo(UnsignedInteger auto value) {
   std::cout << "Unsigned Integer: " << value << std::endl;
}

void foo(UnsignedIntegerOfSize<64> auto value) {
   std::cout << "Unsigned Integer(64): " << value << std::endl;
}

int main() {
   foo(42);     // Integer: 42
   foo(42U);    // Unsigned Integer: 42
   foo(42ULL);  // Unsigned Integer(64): 42
}

template<typename T> using is_bool = std::is_same<std::remove_cv_t<T>, bool>;

_>>Оффтоп. Мимо проходил . По мотивам соседней темы посмотрел на твои is_bool/_is_char: https://github.com/al-martyn1/marty_format/blob/9bc7c73884f74e9fc8dbcc76e5612d504bc21cce/utils.h#L364C51-L364C52.

_>>template<typename T> using is_bool = std::is_same<std::remove_cv_t<T>, bool>;
_>>

template<typename T> using is_bool = std::is_same<std::decay_t<T>, bool>;

template<typename T> concept Bool = std::same_as<std::decay_t<T>, bool>;

static_assert(Bool<const bool&>);

void foo(Bool auto b) {/* . . . */}

_>>Зато еще есть куча всяких целых спец типов __m128i __m256i __m512i

#include <iostream>
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;

int main() {
   cpp_int u=1;
   for(unsigned i=2;i<=100;i++) u*=i;
   std::cout<<u<<std::endl;
   return 0;
}

In file included from example.cpp:2:
/usr/include/boost/multiprecision/cpp_int.hpp: In instantiation of ‘struct boost::multiprecision::backends::cpp_int_base<0, 4294967295, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, std::allocator<long long unsigned int>, false>’:
/usr/include/boost/multiprecision/cpp_int.hpp:1033:8:   required from ‘struct boost::multiprecision::backends::cpp_int_backend<>’
 1033 | struct cpp_int_backend
      |        ^~~~~~~~~~~~~~~
/usr/include/boost/multiprecision/number.hpp:1671:12:   required from ‘class boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<> >’
 1671 |    Backend m_backend;
      |            ^~~~~~~~~
example:6:12:   required from here
    6 |    cpp_int u=1;
      |            ^
/usr/include/boost/multiprecision/cpp_int.hpp:172:8: error: no class template named ‘rebind’ in ‘class std::allocator<long long unsigned int>’
  172 | struct cpp_int_base<MinBits, MaxBits, signed_magnitude, Checked, Allocator, false> : private Allocator::template rebind<limb_type>::other
      |        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/boost/multiprecision/cpp_int.hpp:174:66: error: no class template named ‘rebind’ in ‘class std::allocator<long long unsigned int>’
  174 |    typedef typename Allocator::template rebind<limb_type>::other allocator_type;
      |                                                                  ^~~~~~~~~~~~~~

_>Можно еще вот так извернуться если не нравиться разные но одинаковые типы

template<class T> struct Info {
    enum {
        size=sizeof(T),
        has_sign=(T)-1<0,
        is_2complement=(1&(T)-1),
        code=size*4+has_sign*2+is_2complement
     }; 
};

template<int n>void fnc(const void* t) {
    printf("fn<code=%d> size=%d sign=%d two_comliment=%d\n",n,n/4,(n>>1)&1,n&1); 
}
template<class T>void fn(const T &t) { fnc<Info<T>::code>(&t); }