Как распечатать (используя cout) число в двоичной форме?

Самый простой способ - это, вероятно, создать std::bitset, представляющий значение, а затем передать его в cout.

#include <bitset>
...

char a = -58;
std::bitset<8> x(a);
std::cout << x << '\n';

short c = -315;
std::bitset<16> y(c);
std::cout << y << '\n';

Используйте "на лету" преобразование в std::bitset. Без временных переменных, без циклов, без функций, без макросов.

Live On Coliru

#include <iostream>
#include <bitset>

int main() {
    int a = -58, b = a>>3, c = -315;

    std::cout << "a = " << std::bitset<8>(a)  << std::endl;
    std::cout << "b = " << std::bitset<8>(b)  << std::endl;
    std::cout << "c = " << std::bitset<16>(c) << std::endl;
}

Печать:

a = 11000110
b = 11111000
c = 1111111011000101

Если вы хотите отобразить битовое представление любого объекта, а не только целого числа, не забудьте сначала переинтерпретировать его как массив символов, затем вы можете распечатать содержимое этого массива в шестнадцатеричном или даже двоичном виде (через битовый набор):

#include <iostream>
#include <bitset>
#include <climits>

template<typename T>
void show_binrep(const T& a)
{
    const char* beg = reinterpret_cast<const char*>(&a);
    const char* end = beg + sizeof(a);
    while(beg != end)
        std::cout << std::bitset<CHAR_BIT>(*beg++) << ' ';
    std::cout << '\n';
}
int main()
{
    char a, b;
    short c;
    a = -58;
    c = -315;
    b = a >> 3;
    show_binrep(a);
    show_binrep(b);
    show_binrep(c);
    float f = 3.14;
    show_binrep(f);
}

Обратите внимание, что наиболее распространенные системы имеют прямой порядок байтов, поэтому результат show_binrep(c) не ожидаемый 1111111 011000101, потому что это не то, как он хранится в памяти. Если вы ищете представление значения в двоичном формате, тогда подойдет простой cout << bitset<16>(c).

В C ++ 20 вы сможете использовать std::format для этого:

unsigned char a = -58;
std::cout << std::format("{:b}", a);

Выход:

11000110

А пока вы можете использовать библиотеку {fmt}, на основе std::format. {fmt} также предоставляет функцию print, которая делает это еще проще и эффективнее (godbolt):

unsigned char a = -58;
fmt::print("{:b}", a);

Заявление об ограничении ответственности: я являюсь автором {fmt} и C ++ 20 std::format.

Есть ли в C ++ стандартный способ показать двоичное представление числа в памяти [...]?

Нет. Нет std::bin, например std::hex или std::dec, но вывести двоичное число самостоятельно несложно:

Вы выводите самый левый бит, маскируя все остальные, сдвиг влево и повторяя это для всех битов, которые у вас есть.

(Количество бит в типе sizeof(T) * CHAR_BIT.)

Подобно тому, что уже опубликовано, просто используется битовый сдвиг и маска, чтобы получить бит; может использоваться для любого типа, будучи шаблоном (только не уверен, есть ли стандартный способ получить количество бит в 1 байте, здесь я использовал 8).

#include<iostream>
#include <climits>

template<typename T>
void printBin(const T& t){
    size_t nBytes=sizeof(T);
    char* rawPtr((char*)(&t));
    for(size_t byte=0; byte<nBytes; byte++){
        for(size_t bit=0; bit<CHAR_BIT; bit++){
            std::cout<<(((rawPtr[byte])>>bit)&1);
        }
    }
    std::cout<<std::endl;
};

int main(void){
    for(int i=0; i<50; i++){
        std::cout<<i<<": ";
        printBin(i);
    }
}

Функция многоразового использования:

template<typename T>
static std::string toBinaryString(const T& x)
{
    std::stringstream ss;
    ss << std::bitset<sizeof(T) * 8>(x);
    return ss.str();
}

Использование:

int main(){
  uint16_t x=8;
  std::cout << toBinaryString(x);
}

Это работает со всеми видами целых чисел.

Используя старую версию C ++, вы можете использовать этот фрагмент:

template<typename T>
string toBinary(const T& t)
{
  string s = "";
  int n = sizeof(T)*8;
  for(int i=n-1; i>=0; i--)
  {
    s += (t & (1 << i))?"1":"0";
  }
  return s;
}

int main()
{
  char a, b;

  short c;
  a = -58;
  c = -315;

  b = a >> 3;

  cout << "a = " << a << " => " << toBinary(a) << endl;
  cout << "b = " << b << " => " << toBinary(b) << endl;
  cout << "c = " << c << " => " << toBinary(c) << endl;
}

a = => 11000110
b = => 11111000
c = -315 => 1111111011000101

Использование ответов std :: bitset и удобных шаблонов:

#include <iostream>
#include <bitset>
#include <climits>

template<typename T>
struct BinaryForm {
    BinaryForm(const T& v) : _bs(v) {}
    const std::bitset<sizeof(T)*CHAR_BIT> _bs;
};

template<typename T>
inline std::ostream& operator<<(std::ostream& os, const BinaryForm<T> bf) {
    return os << bf._bs;
}

Используя это так:

auto c = 'A';
std::cout << "c: " << c << " binary: " << BinaryForm{c} << std::endl;
unsigned x = 1234;
std::cout << "x: " << x << " binary: " << BinaryForm{x} << std::endl;
int64_t z { -1024 };
std::cout << "z: " <<  << " binary: " << BinaryForm{z} << std::endl;

Создает вывод:

c: A binary: 01000001
x: 1234 binary: 00000000000000000000010011010010
z: -1024 binary: 1111111111111111111111111111111111111111111111111111110000000000

Вот истинный способ получить двоичное представление числа:

unsigned int i = *(unsigned int*) &x;

Это то, что вы ищете?

std::cout << std::hex << val << std::endl;