std::has_single_bit în C++

Verifică dacă un număr fără semn este o putere a lui 2 (are exact un bit de 1).

Sintaxă
constexpr bool has_single_bit(T x) noexcept;
constexpr T bit_ceil(T x);
constexpr T bit_floor(T x) noexcept;

Ce face std::has_single_bit

std::has_single_bit(x) returnează true pentru 1, 2, 4, 8, 16… adică pentru numerele cu exact un bit setat. Înlocuiește trucul clasic x && !(x & (x - 1)).

Funcțiile înrudite din <bit>: std::bit_ceil(x) dă cea mai mică putere a lui 2 cel puțin egală cu x, iar std::bit_floor(x) cea mai mare putere a lui 2 cel mult egală cu x. Toate primesc doar tipuri fără semn.

Parametri

Parametru Descriere
x Un întreg fără semn.

Ce returnează

true dacă x este o putere a lui 2.

Exemple

Exemplul 1: Puteri ale lui 2

#include <bit>
#include <print>

int main() {
    for (unsigned x : {0u, 1u, 6u, 8u, 1000u, 1024u}) {
        std::println("{:>4}: putere a lui 2 = {}", x, std::has_single_bit(x));
    }
}

Rezultat

   0: putere a lui 2 = false
   1: putere a lui 2 = true
   6: putere a lui 2 = false
   8: putere a lui 2 = true
1000: putere a lui 2 = false
1024: putere a lui 2 = true

Exemplul 2: Mărimea unui buffer rotunjită la putere a lui 2

#include <bit>
#include <print>

int main() {
    for (unsigned cerut : {100u, 512u, 3000u}) {
        std::println("cerut {:>4}: bit_floor = {:>4}, bit_ceil = {:>4}", cerut, std::bit_floor(cerut),
                     std::bit_ceil(cerut));
    }
}

Rezultat

cerut  100: bit_floor =   64, bit_ceil =  128
cerut  512: bit_floor =  512, bit_ceil =  512
cerut 3000: bit_floor = 2048, bit_ceil = 4096

Greșeli frecvente

  • Dai un int: nu compilează, funcțiile din <bit> acceptă doar tipuri fără semn.
  • Apelezi bit_ceil cu o valoare al cărei rezultat nu încape în tip (de exemplu peste 231 pentru unsigned): comportament nedefinit.

Comenzi înrudite

  • std::popcount: Numără câți biți de 1 are un număr întreg fără semn.
  • std::bit_width: Returnează câți biți sunt necesari pentru a reprezenta un număr fără semn (0 pentru 0).
  • std::log: Calculează logaritmul natural (log), în baza 10 (log10) sau în baza 2 (log2) al unui număr pozitiv.