Код писать на языке С++ с использованием битовых операций

          unsigned short int f=...;  // информация о магазине
    
          int num = (f & 0xff00) >> 8;
          cout << "Номер магазина=" << num << endl;
 
          if (f & 1)
            cout << "Бонусная программа есть" << endl;
          else
            cout << "Бонусной программы нет" << endl; 
 
          if (f & 2)
            cout << "Распродажа есть" << endl;
          else
            cout << "Распродажа нет" << endl; 
 
          if (f & 4)
            cout << "Минимальная сумма заказа есть" << endl;
          else
            cout << "Минимальная сумма заказа нет" << endl; 
 
          if (f & 8)
            cout << "Возможность предзаказа есть" << endl;
          else
            cout << "Возможности предзаказа нет" << endl; 
 
          // и т.д.

#include <iostream>
#include <bitset>
 
// функция получения бита номер n
constexpr bool getBit(std::uint16_t number, std::uint8_t n) {
    return number & (std::uint16_t(1) << n);
}
 
// функция установки бита n в значение value
constexpr std::uint16_t setBit(std::uint16_t number, std::uint16_t value, std::uint8_t n) {
    return number ^ ((-value ^ number) & (std::uint16_t(1) << n));
}
 
// этот класс демонстрирует работу с битовми операциями
class Shop {
public:
 
    // для ясности можно создать энум
    enum Property {
        BONUS = 0,
        SALES = 1,
        MINSUM = 2,
        FILTERS = 3,
        PREORDER = 4,
        SUPPORT = 5,
        DELIVERY = 6,
        NIGHT = 7
    };
 
    constexpr Shop(std::uint16_t asInteger) : info{asInteger} {}
 
    constexpr Shop() : info{0} {}
 
    constexpr std::uint16_t asInteger() const {
        return info;
    }
 
    constexpr int getId() const {
        return info >> 8;
    }
 
    void setId(std::uint8_t id) {
        info = info & 255 | (id << 8);
    }
 
    constexpr bool getBonus() const {
        return getBit(info, BONUS);
    }
 
    void setBonus(bool value) {
        info = setBit(info, value ? 1 : 0, BONUS);
    }
 
    constexpr bool getSales() const {
        return getBit(info, SALES);
    }
 
    void setSales(bool value) {
        info = setBit(info, value ? 1 : 0, SALES);
    }
 
    constexpr bool getMinsum() const {
        return getBit(info, MINSUM);
    }
 
    void setMinsum(bool value) {
        info = setBit(info, value ? 1 : 0, MINSUM);
    }
 
    constexpr bool getFilters() const {
        return getBit(info, FILTERS);
    }
 
    void setFilters(bool value) {
        info = setBit(info, value ? 1 : 0, FILTERS);
    }
 
    constexpr bool getPreorder() const {
        return getBit(info, PREORDER);
    }
 
    void setPreorder(bool value) {
        info = setBit(info, value ? 1 : 0, PREORDER);
    }
 
    constexpr bool getSupport() const {
        return getBit(info, SUPPORT);
    }
 
    void setSupport(bool value) {
        info = setBit(info, value ? 1 : 0, SUPPORT);
    }
 
    constexpr bool getDelivery() const {
        return getBit(info, DELIVERY);
    }
 
    void setDelivery(bool value) {
        info = setBit(info, value ? 1 : 0, DELIVERY);
    }
 
    constexpr bool getNight() const {
        return getBit(info, NIGHT);
    }
 
    void setNight(bool value) {
        info = setBit(info, value ? 1 : 0, NIGHT);
    }
 
    // с этого места более продвинутый пример -- доступ через оператор []
    // как на чтение, так и на запись
    // так можно убрать 75 строк геттеров и сеттеров и обеспечить, например,
    // проход по всем свойствам в цикле.
    struct BitOp {
        std::uint16_t &number;
        std::uint8_t n;
 
        constexpr BitOp(std::uint16_t &number, std::uint8_t n) : number(number), n(n) {}
 
        constexpr operator bool() const { return getBit(number, n); }
 
        BitOp &operator=(bool value) {
            number = setBit(number, value ? 1 : 0, n);
            return *this;
        }
    };
 
    // то же самое в неизменяемом, константном, контексте
    struct ConstBitOp {
        const std::uint16_t &number;
        std::uint8_t n;
 
        constexpr ConstBitOp(const std::uint16_t &number, std::uint8_t n) : number(number), n(n) {}
 
        constexpr operator bool() const { return getBit(number, n); }
    };
 
    // оператор доступа по индексу
    BitOp operator[](const Property &property) {
        return BitOp(info, static_cast<std::uint8_t>(property));
    }
 
    // то же самое в неизменяемом, константном, контексте
    constexpr ConstBitOp operator[](const Property &property) const {
        return ConstBitOp(info, static_cast<std::uint8_t>(property));
    }
 
private:
    std::uint16_t info; // числовое значение
};
 
// демонстрация работы с битовыми полями
// оператор вывода
std::ostream &operator<<(std::ostream &out, const Shop &info) {
    return out << std::boolalpha << "Shop{"
               << "id: " << +info.getId() << ", "
               << "bonus: " << info.getBonus() << ", "
               << "sales: " << info.getSales() << ", "
               << "minsum: " << info.getMinsum() << ", "
               << "filters: " << info.getFilters() << ", "
               << "preorder: " << info.getPreorder() << ", "
               << "support: " << info.getSupport() << ", "
               << "delivery: " << info.getDelivery() << ", "
               << "night: " << info.getNight() << ", "
               << "bitset: " << std::bitset<16>(info.asInteger()) << "}";
}
 
 
int main() {
    // класс магазина
    Shop shop(0xFF0F);
 
    // использование оператора доступа по индексу
    std::cout << "Was: " << std::boolalpha << shop[Shop::NIGHT] << std::endl;
    shop[Shop::NIGHT] = true;
    std::cout << "Now: " << std::boolalpha << shop[Shop::NIGHT] << std::endl;
 
    // демонстрация доступа к битам числа через методы класса
    std::cout << shop << std::endl;
 
    return 0;
}