473,378 Members | 1,429 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,378 software developers and data experts.

typesafe bitwise operations based on enums

Hi,
I just wanted to share another library for doing type-safe bitwise
operations in C++:
http://bitwise-enum.googlecode.com

I found it useful, so hopefully it'll be for somebody else as well.

BRgds,
Daniel.
Jan 10 '08 #1
8 8761
On Jan 10, 2:06 pm, Daniel Gutson <danielgut...@gmail.comwrote:
I just wanted to share another library for doing type-safe bitwise
operations in C++:
http://bitwise-enum.googlecode.com
Well, it has a number of problems. The most basic one is, of
course, that the results of or'ing or and'ing an enum aren't the
expected type. And of course, it fails for some enums.

What's wrong with just:

#define defineEnumOps( Enum, Underlying ) \
inline \
Enum operator|( Enum lhs, Enum rhs ) \
{ \
return static_cast< Enum >( \
static_cast< Underlying >( lhs ) \
| static_cast< Underlying >( rhs ) ) ; \
} \
inline \
Enum& operator|=( Enum& lhs, Enum rhs ) \
{ \
lhs = lsh | rhs ; \
return lsh ; \
} \
// and so on...

I've got code which actually parses the source file and
generates the operators directly, rather than using a #define.
But that's only because it was easy to add this to my code which
generated the enum<->string mappings---once you have the parser
and all of the information, generating the above is trivial, but
it's not worth writing all that for just the operators.

The real difficult is, of course, the underlying type. You're
probably safe using "unsigned long" in all cases, unless the
compiler also supports long long. I've found it acceptable to
require the user to provide it (defaulting to unsigned int in
the case of the code generator).

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Jan 10 '08 #2
James Kanze wrote:
On Jan 10, 2:06 pm, Daniel Gutson <danielgut...@gmail.comwrote:
> I just wanted to share another library for doing type-safe bitwise
operations in C++:
http://bitwise-enum.googlecode.com

Well, it has a number of problems. The most basic one is, of
course, that the results of or'ing or and'ing an enum aren't the
expected type. And of course, it fails for some enums.

What's wrong with just:

#define defineEnumOps( Enum, Underlying ) \
inline \
Enum operator|( Enum lhs, Enum rhs ) \
{ \
return static_cast< Enum >( \
static_cast< Underlying >( lhs ) \
| static_cast< Underlying >( rhs ) ) ; \
} \
inline \
Enum& operator|=( Enum& lhs, Enum rhs ) \
{ \
lhs = lsh | rhs ; \
return lsh ; \
} \
// and so on...
<snip>

I have not read the implementation, but from the example on the site seems
that the library is intended for a different purpose then what your code is
for. It's not suposed to be used when as the result of a bitwise operation
it results the same enum type (as you said that that does not make sense
all the time) it is only made so that you can "safely" declare a function
saying that this function should take an integral value that is the result
of bitwise operations of this enum. I supose the function knowing this can
assume various things on that integral and work with it in some specific
way.

Tho I am not even sure that the library does achieve that (or if it is
possible to achieve it).

--
Dizzy

Jan 10 '08 #3
On 2008-01-10 10:47:47 -0500, Daniel Gutson <da**********@gmail.comsaid:
- however, grouping related (and combinable) bitmasks is not
'typesafe': if a function receives a mask of LEDs bits, and another
receives a mask of FANs bits, no matter if you group the bits in
different enumerations, once you or them, you'll loose the type.
That doesn't happen if you overload the bitwise operators for your
enumerated type.
>
My library tries to solve this:
given the enums above, you can then:

typedef bitwise_enum<LED_BITSLeds_mask;
typedef bitwise_enum<FAN_BITSFans_mask;

void set_leds(Leds_mask mask);
void turn_fans(Fans_mask mask);

int main() {
set_leds(GREEN_LED | KITCHEN_FAN); // Compiler error
}

Moreover, you can now overload functions depending on the mask.

Hope it's clearer now! And thanks Dizzy for helping me to clarify.
It's clearer, but what's the advantage of this approach over defining
operator| and operator& for the enum type, and simply writing functions
that take that enum?

LED_BITS operator|(LED_BITS left, LED_BITS right)
{
return static_cast<LED_BITS>(left | right);
}

LED_BITS operator&(LED_BITS left, LED_BITS right)
{
return static_cast<LED_BITS>(left & right);
}

void set_leds(LED_BITS mask);
set_leds(GREEN_LED | KITCHEN_FAN); // compiler error

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

Jan 10 '08 #4
On Jan 10, 1:56*pm, Pete Becker <p...@versatilecoding.comwrote:
On 2008-01-10 10:47:47 -0500, Daniel Gutson <danielgut...@gmail.comsaid:
*- however, grouping related (and combinable) bitmasks is not
'typesafe': if a function receives a mask of LEDs bits, and another
receives a mask of FANs bits, no matter if you group the bits in
different enumerations, once you or them, you'll loose the type.

That doesn't happen if you overload the bitwise operators for your
enumerated type.


My library tries to solve this:
given the enums above, you can then:
typedef bitwise_enum<LED_BITSLeds_mask;
typedef bitwise_enum<FAN_BITSFans_mask;
void set_leds(Leds_mask mask);
void turn_fans(Fans_mask mask);
int main() {
* set_leds(GREEN_LED | KITCHEN_FAN); * // Compiler error
}
Moreover, you can now overload functions depending on the mask.
Hope it's clearer now! And thanks Dizzy for helping me to clarify.

It's clearer, but what's the advantage of this approach over defining
operator| and operator& for the enum type, and simply writing functions
that take that enum?

LED_BITS operator|(LED_BITS left, LED_BITS right)
{
return static_cast<LED_BITS>(left | right);

}

LED_BITS operator&(LED_BITS left, LED_BITS right)
{
return static_cast<LED_BITS>(left & right);

}

void set_leds(LED_BITS mask);
set_leds(GREEN_LED | KITCHEN_FAN); * * *// compiler error

--
* Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)- Hide quoted text -

- Show quoted text -
Hi Pete.
I don't like having enum variables holding values that are not enums.
That's a hack. And I simply think that the right way to do that is a
class. Why not? It doesn't add any overhead, neither does any wrong.

Daniel.
Jan 10 '08 #5
On 2008-01-10 11:08:15 -0500, Daniel Gutson <da**********@gmail.comsaid:
I don't like having enum variables holding values that are not enums.
That's a hack.
It's an intended property of enum types. Each enum's underlying type is
required to be large enough to hold all the bits that make up every
value (that's not exactly the requirement, but you get the point),
precisely so that this kind of code will work.
And I simply think that the right way to do that is a
class. Why not? It doesn't add any overhead, neither does any wrong.
It adds mental overhead, having to remember that objects of type
LED_BITS combine to create objects of type bitwise_enum<LED_BITS>.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

Jan 10 '08 #6
class. Why not? It doesn't add any overhead, neither does any wrong.
>
It adds mental overhead, having to remember that objects of type
LED_BITS combine to create objects of type bitwise_enum<LED_BITS>.
C'mon man!! Don't be that lazy! :D
Do a typedef and you're done!!

Daniel.
Jan 10 '08 #7
On 2008-01-10 12:20:49 -0500, Daniel Gutson <da**********@gmail.comsaid:
>>class. Why not? It doesn't add any overhead, neither does any wrong.

It adds mental overhead, having to remember that objects of type
LED_BITS combine to create objects of type bitwise_enum<LED_BITS>.

C'mon man!! Don't be that lazy! :D
Sigh.
Do a typedef and you're done!!
Whatever you call it, it's two different names, wiht different
properties, for what should be the same thing.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

Jan 10 '08 #8
On Jan 10, 5:08 pm, Daniel Gutson <danielgut...@gmail.comwrote:
I don't like having enum variables holding values that are not
enums. That's a hack.
It's a design feature of C++ enums. A C++ enum is not (just) an
enumerated type. I agree that the language would be clearer if
it distinguished between enumerated types and bitmap types, but
it doesn't. The keyword enum is used for both.
And I simply think that the right way to do that is a class.
Why not? It doesn't add any overhead, neither does any wrong.
If you're going that route (and I can understand it), then
wouldn't the "correct" solution be something like:

class Leds
{
public:
static Leds const redLed ;
static Leds const greenLed ;
static Leds const blueLed ;

Leds() ; // all off.
Leds( Leds const& other ) ;
Leds& operator|=( Leds const& other ) ;
Leds& operator&=( Leds const& other ) ;
freind Leds operator~( Leds const& op ) ;

private:
unsigned int myValue ;
explicit Leds( unsigned int value ) ;
} ;

Leds operator|( Leds const& lhs, Leds const& rhs ) ;
Leds operator&( Leds const& lhs, Leds const& rhs ) ;

Internally, you use bits and a bit mask on myValue, but all the
user sees is some values which he can manipulate:

Leds l1 ;
l1 |= redLed ;
Leds l2( l1 | greenLed ) ;

It seems a bit heavy to me, but it's certainly the most
"correct" in the abstract sense. And if you need to do it a
lot... it would take about ten minutes to write an AWK script to
generate the class, given the class name and a list of its
(constant) values.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Jan 11 '08 #9

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

8
by: Paul E Collins | last post by:
Suppose I have a few Keys objects: Keys k1 = Keys.V; // V Keys k2 = Keys.Control | Keys.V; // Ctrl+V Keys k3 = Keys.Shift | Keys.J; // Shift+J I need to determine which of these include the...
9
by: Christopher Weaver | last post by:
I know that the bitwise AND of 8 and 4 will return 0 or false and the bitwise AND of 8 and 9 will return 1 or true but I don't know how to write the synax for it in C#. I have a value that ranges...
2
by: Random | last post by:
I need to apply a filterparameter to a result set in my GridView based on the selection in a DropDownList control. I want to use the integer SelectedValue property of the DropDownList to filter...
4
by: AMDRIT | last post by:
Gang, I always get confused when it comes to 1's and 0's. I would like to perform a bitwise operation on a value based on checked boxes. Am I doing this right? assuming...
17
by: zirconx | last post by:
I'm trying to understand how the bitwise AND can be used. I've read about what it does but am having trouble applying it practically. I'm working on a system that somebody else wrote and they...
34
by: Steven Nagy | last post by:
So I was needing some extra power from my enums and implemented the typesafe enum pattern. And it got me to thinking... why should I EVER use standard enums? There's now a nice little code...
45
by: Carramba | last post by:
Hi! I now that I can't do straight forward any bitwise operation on float (double etc..). But I wondering what is the easiest/best way to do this? I was thinking if I have float x=1.1111 so I can...
8
by: Travis | last post by:
I don't have too much experience with bitwise operations. Here is what I'm trying to accomplish. I have enum say: enum myEnum { BILL = 0, KATIE = 1, JOHN = 2 } Then I have an int that...
29
by: Carl Banks | last post by:
Anyone with me here? (I know the deadline for P3 PEPs has passed; this is just talk.) Not many people are bit-fiddling these days. One of the main uses of bit fields is flags, but that's not...
1
by: CloudSolutions | last post by:
Introduction: For many beginners and individual users, requiring a credit card and email registration may pose a barrier when starting to use cloud servers. However, some cloud server providers now...
0
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 3 Apr 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome former...
0
by: taylorcarr | last post by:
A Canon printer is a smart device known for being advanced, efficient, and reliable. It is designed for home, office, and hybrid workspace use and can also be used for a variety of purposes. However,...
0
by: Charles Arthur | last post by:
How do i turn on java script on a villaon, callus and itel keypad mobile phone
0
by: aa123db | last post by:
Variable and constants Use var or let for variables and const fror constants. Var foo ='bar'; Let foo ='bar';const baz ='bar'; Functions function $name$ ($parameters$) { } ...
0
by: ryjfgjl | last post by:
If we have dozens or hundreds of excel to import into the database, if we use the excel import function provided by database editors such as navicat, it will be extremely tedious and time-consuming...
0
by: ryjfgjl | last post by:
In our work, we often receive Excel tables with data in the same format. If we want to analyze these data, it can be difficult to analyze them because the data is spread across multiple Excel files...
1
by: nemocccc | last post by:
hello, everyone, I want to develop a software for my android phone for daily needs, any suggestions?
1
by: Sonnysonu | last post by:
This is the data of csv file 1 2 3 1 2 3 1 2 3 1 2 3 2 3 2 3 3 the lengths should be different i have to store the data by column-wise with in the specific length. suppose the i have to...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.