Digite Bitflags seguros (R) em C ++?
-
26-09-2019 - |
Pergunta
Ao revisar um código C ++ antigo, encontrei vários bitflags definido como enums.
enum FooFlags
{
FooFlag1 = 1 << 0,
FooFlag2 = 1 << 1,
FooFlag3 = 1 << 2
// etc...
};
Isso não é incomum, mas me incomodou que, assim que você começa a combinar bandeiras, você perde as informações do tipo.
int flags = FooFlag1 | FooFlag2; // We've lost the information that this is a set of flags relating to *Foo*
Alguns pesquisando, então mostraram que não sou o só 1 incomodado com isso.
Uma alternativa é declarar sinalizadores como #Defines ou Const Integrals, as operações tão bites não transformariam o tipo (provavelmente). O problema com isso é que ele permite que nosso conjunto se misture com sinalizadores não relacionados, via INTs ou outros enumes.
Estou familiarizado com std :: bitset e Boost :: Dynamic_bitset, mas nenhum deles foi projetado para resolver meu problema. O que estou procurando é algo como C#' Flagsattribute.
Minha pergunta é: que outras soluções existem para um (mais) conjunto seguro de bitflags?
Vou postar minha própria solução abaixo.
Solução 2
Aqui está minha própria solução, usando elementos de C ++ 0x que a versão atual do VS2010 permite:
#include <iostream>
#include <numeric>
#include <string>
#include <initializer_list>
template <typename enumT>
class FlagSet
{
public:
typedef enumT enum_type;
typedef decltype(enumT()|enumT()) store_type;
// Default constructor (all 0s)
FlagSet() : FlagSet(store_type(0))
{
}
// Initializer list constructor
FlagSet(const std::initializer_list<enum_type>& initList)
{
// This line didn't work in the initializer list like I thought it would. It seems to dislike the use of the lambda. Forbidden, or a compiler bug?
flags_ = std::accumulate(initList.begin(), initList.end(), store_type(0), [](enum_type x, enum_type y) { return x | y; })
}
// Value constructor
explicit FlagSet(store_type value) : flags_(value)
{
}
// Explicit conversion operator
operator store_type() const
{
return flags_;
}
operator std::string() const
{
return to_string();
}
bool operator [] (enum_type flag) const
{
return test(flag);
}
std::string to_string() const
{
std::string str(size(), '0');
for(size_t x = 0; x < size(); ++x)
{
str[size()-x-1] = (flags_ & (1<<x) ? '1' : '0');
}
return str;
}
FlagSet& set()
{
flags_ = ~store_type(0);
return *this;
}
FlagSet& set(enum_type flag, bool val = true)
{
flags_ = (val ? (flags_|flag) : (flags_&~flag));
return *this;
}
FlagSet& reset()
{
flags_ = store_type(0);
return *this;
}
FlagSet& reset(enum_type flag)
{
flags_ &= ~flag;
return *this;
}
FlagSet& flip()
{
flags_ = ~flags_;
return *this;
}
FlagSet& flip(enum_type flag)
{
flags_ ^= flag;
return *this;
}
size_t count() const
{
// http://www-graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
store_type bits = flags_;
size_t total = 0;
for (; bits != 0; ++total)
{
bits &= bits - 1; // clear the least significant bit set
}
return total;
}
/*constexpr*/ size_t size() const // constexpr not supported in vs2010 yet
{
return sizeof(enum_type)*8;
}
bool test(enum_type flag) const
{
return (flags_ & flag) > 0;
}
bool any() const
{
return flags_ > 0;
}
bool none() const
{
return flags == 0;
}
private:
store_type flags_;
};
template<typename enumT>
FlagSet<enumT> operator & (const FlagSet<enumT>& lhs, const FlagSet<enumT>& rhs)
{
return FlagSet<enumT>(FlagSet<enumT>::store_type(lhs) & FlagSet<enumT>::store_type(rhs));
}
template<typename enumT>
FlagSet<enumT> operator | (const FlagSet<enumT>& lhs, const FlagSet<enumT>& rhs)
{
return FlagSet<enumT>(FlagSet<enumT>::store_type(lhs) | FlagSet<enumT>::store_type(rhs));
}
template<typename enumT>
FlagSet<enumT> operator ^ (const FlagSet<enumT>& lhs, const FlagSet<enumT>& rhs)
{
return FlagSet<enumT>(FlagSet<enumT>::store_type(lhs) ^ FlagSet<enumT>::store_type(rhs));
}
template <class charT, class traits, typename enumT>
std::basic_ostream<charT, traits> & operator << (std::basic_ostream<charT, traits>& os, const FlagSet<enumT>& flagSet)
{
return os << flagSet.to_string();
}
A interface é modelada depois std :: bitset. Meu objetivo era ser fiel ao etano C ++ da segurança do tipo e da sobrecarga mínima (se houver). Eu daria as boas -vindas a qualquer feedback sobre minha implementação.
Aqui está um exemplo mínimo:
#include <iostream>
enum KeyMod
{
Alt = 1 << 0, // 1
Shift = 1 << 1, // 2
Control = 1 << 2 // 4
};
void printState(const FlagSet<KeyMod>& keyMods)
{
std::cout << "Alt is " << (keyMods.test(Alt) ? "set" : "unset") << ".\n";
std::cout << "Shift is " << (keyMods.test(Shift) ? "set" : "unset") << ".\n";
std::cout << "Control is " << (keyMods.test(Control) ? "set" : "unset") << ".\n";
}
int main(int argc, char* argv[])
{
FlagSet<KeyMod> keyMods(Shift | Control);
printState(keyMods);
keyMods.set(Alt);
//keyMods.set(24); // error - an int is not a KeyMod value
keyMods.set(Shift);
keyMods.flip(Control);
printState(keyMods);
return 0;
}
Outras dicas
Você pode sobrecarregar os operadores para tipos de enumeração que retornam o resultado digitado adequado.
inline FooFlags operator|(FooFlags a, FooFlags b) {
return static_cast<FooFlags>(+a | +b);
}
Deve -se notar que, para ser teoricamente seguro, você deve declarar manualmente o maior valor possível para que o intervalo do tipo de enumeração seja garantido para capturar todas as combinações.
- Na verdade, isso não é necessário: o alcance de uma enumeração sempre poderá capturar toda a combinação, porque o maior valor positivo da faixa de uma enumeração é sempre
(2^N)-1
pela primeira vezN
Ser capaz de representar o enumerador mais alto. Esse valor tem todos os bits 1.
Pensei que poderia adicionar uma versão C ++ 11 para enum class
FooFlags operator|(FooFlags a, FooFlags b)
{
typedef std::underlying_type<FooFlags>::type enum_type;
return static_cast<FooFlags>(static_cast<enum_type>(a) | static_cast<enum_type>(b));
}
Se você a versão C ++ 11 suporta, acho que seria um candidato principal para constexpr