[英]In C++: Is it possible to have a named enum be continued in a different file?
[英]Is it possible to have enum of enums in c++?
是否有可能在c ++中枚舉枚舉。 我必須有類似的東西:
錯誤類型:
類型1:
類型2:
類型3:
這些中的每一個都是整數值。 它們應該用在通信協議棧中。 在接收端,接收器必須從接收的值中解碼錯誤的類型和原因。 如果不能使用枚舉,最好的方法是什么?
我甚至不確定枚舉的含義是什么意思。 但通常的處理方法是在單個枚舉中定義范圍:
enum Errors
{
type1 = 0x000,
cause1,
cause2,
type2 = 0x100,
cause3,
cause4,
...
causeMask = 0xFF,
typeMask = 0xFF00
};
或者簡單地用單獨的單詞定義單獨的枚舉,並使用unsigned
(或unsigned short
或任何)和不同原因的一些轉換。
無論采用何種解決方案,我都會將其封裝在一個類中,以便客戶端代碼只需要處理errorType()
和errorType()
errorCause()
; errorCause()
甚至可以是錯誤類型值的模板。 (但在某個地方,您需要為每個類型值顯式特化,因為編譯器不會知道如何將值映射到導致類型。)
我不建議這樣做。 更喜歡使用顯式錯誤類型,其中包含有關錯誤的信息(您可以添加字符串等)。 這也不是很安全。 另見詹姆斯回答。
但無論如何這里是邪惡的宏版本:
#define DECL_ERROR_TYPE(errorType, value) , errorType = value << 16
#define DECL_ERROR(errorType, cause, value) , errorType##_##cause = (errorType + value)
#define GET_ERROR_TYPE(error) (error & 0xFFFF0000)
enum Error
{
NoError = 0
DECL_ERROR_TYPE(Type1, 1)
DECL_ERROR(Type1, Cause1, 1)
DECL_ERROR(Type1, Cause2, 2)
DECL_ERROR_TYPE(Type2, 2)
DECL_ERROR(Type2, Cause1, 1)
DECL_ERROR_TYPE(Type3, 3)
DECL_ERROR(Type3, Cause1, 1)
DECL_ERROR(Type3, Cause2, 2)
};
這允許你像這樣使用它:
Error err1 = Type1_Cause1;
if(Type1 == GET_ERROR_TYPE(err1))
return 0; // Works
正如傑瑞所說,這是不可能直接的。 解決此問題的一種方法是使用兩個枚舉。 一個用於類別,一個用於子類別。
但是,正如georgesl所說,在協議中執行此操作可能會很危險。 你肯定應該明確定義枚舉值:
struct Error
{
enum Type {
UNKNOWNTYPE = 0,
TYPE1 = 1,
TYPE2 = 2,
TYPE3 = 3
};
enum Subtype {
UNKNOWNSUBTYPE = 0,
// subtype for error type 1
CAUSE1 = 1001,
CAUSE2 = 1002,
CAUSE3 = 1003,
// subtype for error type 2
CAUSE4 = 2001,
CAUSE5 = 2002
};
Type type;
Subtype subtype;
};
int main()
{
Error error;
error.type = Error::TYPE1;
error.subtype = Error::CAUSE1;
}
確保明智地選擇數字以用於將來的擴展。
更新:使示例實際工作。
替代的,更安全的解決方案:
struct ErrorType
{
enum type {
UNKNOWNTYPE = 0,
TYPE1 = 1,
TYPE2 = 2,
TYPE3 = 3
};
};
struct ErrorSubtype
{
enum type {
UNKNOWNSUBTYPE = 0,
// subtype for error type 1
CAUSE1 = 1001,
CAUSE2 = 1002,
CAUSE3 = 1003,
// subtype for error type 2
CAUSE4 = 2001,
CAUSE5 = 2002
};
};
struct Error
{
ErrorType::type type;
ErrorSubtype::type subtype;
};
int main()
{
Error error;
error.type = ErrorType::TYPE1;
error.subtype = ErrorSubtype::CAUSE1;
}
我無法忍受使用枚舉。 所以我有另一個使用顯式類型的答案。 它不完整但顯示正確的方向,並包含添加描述等的可能擴展。
這是聲明的代碼:
struct Error
{
public:
struct ErrorType
{
int _code;
ErrorType(int code) : _code(code << 16) {}
};
private:
friend struct Errors;
ErrorType _type;
int _code;
Error(ErrorType type, int causeCode)
: _type(type), _code(causeCode)
{
}
static std::map<int, Error> _errors;
public:
Error() : _type(-1), _code(-1) {}
static Error FromCode(int code) { return _errors[code]; }
bool IsOfType(const ErrorType& type )
{
return _type._code == type._code;
}
operator int()
{
return _code | _type._code;
}
bool operator == (Error const& other) const
{
return _code == other._code && _type._code == other._type._code;
}
bool operator != (Error const& other) const
{
return _code != other._code || _type._code != other._type._code;;
}
};
std::map<int, Error> Error::_errors;
struct Errors
{
#define BEGIN_TYPE(type, code) struct type : Error::ErrorType { type() : ErrorType(code) {} typedef Errors::##type CurrentType;
#define CAUSE(cause, code) struct cause : Error { cause() : Error(CurrentType(),code) { Error::_errors[*this] = *this; } };
#define END_TYPE() };
// first type is coded manually to show what the macros do...
struct Type1 : Error::ErrorType
{
Type1() : ErrorType(1) { }
typedef Errors::Type1 CurrentType;
struct Cause1 : Error
{
Cause1() : Error(CurrentType(),1) { Error::_errors[*this] = *this; }
};
struct Cause2 : Error
{
Cause2() : Error(CurrentType(),2) { Error::_errors[*this] = *this; }
};
};
BEGIN_TYPE(Type2, 2)
CAUSE(Cause1, 1)
CAUSE(Cause2, 2)
END_TYPE()
};
以下是一些示例用法:
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Error err = Errors::Type1::Cause1();
Q_ASSERT( err.IsOfType(Errors::Type1()) );
Q_ASSERT( Errors::Type1::Cause1() == Errors::Type1::Cause1() );
Q_ASSERT( Errors::Type1::Cause1() != Errors::Type2::Cause1() );
int code = err;
qDebug() << code;
Q_ASSERT( Error::FromCode(code) == Errors::Type1::Cause1() );
Q_ASSERT( Error::FromCode(code) != Errors::Type2::Cause1() );
Q_ASSERT( Error::FromCode(code).IsOfType(Errors::Type1()) );
return a.exec();
}
這不是一個完美的解決方案,但展示了如何以更明確的方式處理這個問題。 人們可以做很多改進......
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.