Как установить, сбросить и переключить отдельный бит в C++?

Основы: побитовые операции

В C++ для работы с отдельными битами используются три побитовые операции:

• Установка бита (set) — операция | (побитовое ИЛИ)
• Сброс бита (clear) — операция & (побитовое И) с инвертированной маской
• Переключение бита (toggle) — операция ^ (побитовое исключающее ИЛИ)

Главная проблема новичков — ручное вычисление масок. Её решают сдвигом единицы на нужную позицию: (1 << n), где n — номер бита (с нуля).

Правильная нумерация битов

В программировании биты всегда нумеруются с нуля (младший бит — позиция 0). Это соответствует степени двойки: бит 0 = 2⁰ = 1, бит 3 = 2³ = 8. Запомните: (1 << 3) == 8.

Решения для вашего примера

uint8_t flags = 0b00001111; // исходное значение

// 1. Установить 3-й бит в 1
flags |= (1 << 3);  // flags = flags | (1 << 3)

// 2. Сбросить 2-й бит в 0
flags &= ~(1 << 2); // flags = flags & ~(1 << 2)

// 3. Переключить 1-й бит
flags ^= (1 << 1);  // flags = flags ^ (1 << 1)

Почему это работает?

• (1 << n) создаёт маску с единицей в позиции n. Например, 1 << 3 даёт 0b00001000.
• ~ инвертирует маску: ~(1 << 2) = 0b11111011. При И (&) все биты, кроме нужного, остаются без изменений.
• Для переключения XOR (^) с единицей инвертирует бит, а с нулём — оставляет как есть.

Рекомендуемые макросы/функции

Чтобы код был читаемым, используйте константы или шаблоны:

// Вариант 1: макросы (как в ядре Linux)
#define SET_BIT(reg, n)   ((reg) |= (1 << (n)))
#define CLEAR_BIT(reg, n) ((reg) &= ~(1 << (n)))
#define TOGGLE_BIT(reg, n)((reg) ^= (1 << (n)))

// Использование:
SET_BIT(flags, 3);
CLEAR_BIT(flags, 2);
TOGGLE_BIT(flags, 1);

// Вариант 2: inline-функции (безопаснее, нет проблем с макросами)
inline void set_bit(uint8_t& reg, uint8_t n)   { reg |= (1 << n); }
inline void clear_bit(uint8_t& reg, uint8_t n) { reg &= ~(1 << n); }
inline void toggle_bit(uint8_t& reg, uint8_t n){ reg ^= (1 << n); }

Проверка бита

Дополнительно — чтение состояния бита:

bool is_bit_set(uint8_t reg, uint8_t n) {
    return (reg >> n) & 1; // или просто (reg & (1 << n)) != 0
}

Советы для микроконтроллеров

• Используйте volatile для регистров: volatile uint8_t* reg = ...
• Для AVR есть встроенные макросы _BV(n) (Bit Value) — то же самое, что (1 << n).
• Избегайте макросов с аргументами, которые имеют побочные эффекты (например, SET_BIT(*reg++, 3) сломается).

Полный пример

#include <iostream>
#include <cstdint>

int main() {
    uint8_t flags = 0b00001111;
    
    std::cout << "Исходное: " << (int)flags << "\n";
    
    flags |= (1 << 3);   // установить бит 3
    std::cout << "После set 3: " << (int)flags << "\n";
    
    flags &= ~(1 << 2);  // сбросить бит 2
    std::cout << "После clear 2: " << (int)flags << "\n";
    
    flags ^= (1 << 1);   // переключить бит 1
    std::cout << "После toggle 1: " << (int)flags << "\n";
    
    return 0;
}

Вывод:

Исходное: 15
После set 3: 15    // бит 3 уже был 1
После clear 2: 11  // 0b00001011
После toggle 1: 9  // 0b00001001

struct Flags {
    uint8_t bit0 : 1;
    uint8_t bit1 : 1;
    uint8_t bit2 : 1;
    uint8_t bit3 : 1;
    uint8_t padding : 4; // оставшиеся биты
};

int main() {
    Flags flags;
    flags.bit0 = 1;
    flags.bit1 = 0;
    flags.bit2 = 1;
    
    // Переключение:
    flags.bit3 = !flags.bit3;
    
    // Доступ к сырым данным:
    uint8_t raw = *reinterpret_cast<uint8_t*>(&flags);
    return 0;
}