enumeration design question

Hello

When you use enum inside a class, how do you implement it?

Suppose you have:

Code:

---

class someclass {
public:
  enum state_type {
    work = 1,
    sleep
  };
 
  state_type m_state;
};

m_state = work;

---

or would you put enum state_type in a structure (for instance struct state) so you could write:

Code:

---

state::state_type somestate = state::work;

---

which looks nicer if you ask me.

What do you think?

Thanks for answers!

Just use an anonymous enumeration (a fancy word for not giving it a name)

Example:

Code:

---

class state {
public:
  enum {
    Arkansas = 1,
    Alaska,
    California
  };
};

---

Tada! :)

Quote:

---

Originally Posted by master5001

Just use an anonymous enumeration (a fancy word for not giving it a name)

Example:

Code:

---

class state {
public:
  enum {
    Arkansas = 1,
    Alaska,
    California
  };
};

---

Tada! :)

---

How do you define it this way?

Code:

---

state blah = state::Alaska;

---

?

Example:

Code:

---

class state {
public:
  enum {
    Undefined = 0,
    Arkansas = 1,
    Alaska,
    California
  };

protected:
  int value;

public:
  state() : value(Undefined) { }
  state(int val) : value(val) { }
  state(const state &o) : value(o.value) { }

  state operator=(int val)
  {
    value = val;
  }
};

---

This kind of allows you to do what you want from all angles.. Though its a lot of work for such little gain.... You deserve a job at Microsoft :)

Why not put it in a namespace?

Code:

---

namespace Food
{
  enum Vegetables
  {
      Onion = 1,
      Potato = 2
  };

  enum Fruits
  {
      Apple = 1,
      Orange = 2
  };
}

---

Quote:

---

Originally Posted by master5001

Example:

Code:

---

class state {
public:
  enum {
    Undefined = 0,
    Arkansas = 1,
    Alaska,
    California
  };

protected:
  int value;

public:
  state() : value(Undefined) { }
  state(int val) : value(val) { }
  state(const state &o) : value(o.value) { }

  state operator=(int val)
  {
    value = val;
  }
};

---

This kind of allows you to do what you want from all angles.. Though its a lot of work for such little gain.... You deserve a job at Microsoft :)

---

Is there any way to make state class more flexibile, so I wouldnt have to write it for each different enum?

Maybe templated class, something like:

Code:

---

enum test_enum {
  bla = 1,
  blabla = 2
};

template <typename T>
class state {
public:
        typedef enum T s;

protected:
        int value;

public:
        state() : value(0) { }
        state(int val) : value(val) { }
        state(const state &o) : value(o.value) { }

        state operator=(int val) {
                value = val;
        }
};

---

and then:

Code:

---

state<test_enum> test;
test = state::bla;

---

Is this possible?

What is the REAL problem you are trying to solve?

All of the above solutions, plus several handfuls more could be used - it's all about what you are trying to achieve - here's my suggestions to solving some of the possible problems you may be looking at:
1. Isolation/namespace: just make sure that the "work" is not cluttering up the global namespace, use either a class or namespace (I prefer the namespace solution myself).
2. Ensuring correct use: wrap the state in a class, so that it's "impossible" to misuse the state.
3. Something else? No suggestion until further details of why you want to do this.

My personal feeling is that "don't make things more complex for no reason" - so if there's a good reason for putting the enum in a namespace, then do so. If not, then don't. If there's a good reason to wrap the enum in a class, then do so.

--
Mats

Quote:

---

Originally Posted by matsp

What is the REAL problem you are trying to solve?

All of the above solutions, plus several handfuls more could be used - it's all about what you are trying to achieve - here's my suggestions to solving some of the possible problems you may be looking at:
1. Isolation/namespace: just make sure that the "work" is not cluttering up the global namespace, use either a class or namespace (I prefer the namespace solution myself).
2. Ensuring correct use: wrap the state in a class, so that it's "impossible" to misuse the state.
3. Something else? No suggestion until further details of why you want to do this.

My personal feeling is that "don't make things more complex for no reason" - so if there's a good reason for putting the enum in a namespace, then do so. If not, then don't. If there's a good reason to wrap the enum in a class, then do so.

--
Mats

---

The reason is I have an enum that is being used by two projects (in the same workspace) so I need to have it in shared files and I want to have everything organized as much as possible.

I'd use a namespace for that purpose. It gives the "isolation" (that is, this enum will never collide with another enum defined locally in either of the two projects), at the same time as there is no unnecessary overhead.

--
Mats

I'm having problems with how to name it properly..

This enum is enum for client state..

So if I put it in a namespace client this way:

Code:

---

namespace client {
  enum state { standby = 1 };
};

client::state some_state = client::standby;

---

or:

Code:

---

namespace client_state {
  enum state { standby = 1 };
};

client_state::state some_state = client_state::standby;

---

Which way do you prefer? I would prefer client::state::standby if that would be possible thats why I've been considering above approach with putting it in a class..

state gets repeated in your second example, which doesn't add any useful information. Not adding anything of value -> don't use it. My personal view, of course.

--
Mats

Quote:

---

Originally Posted by matsp

state gets repeated in your second example, which doesn't add any useful information. Not adding anything of value -> don't use it. My personal view, of course.

--
Mats

---

Thanks a lot Mats!

One other point: You may find that OTHER things that are shared can go into the same namespace, and that would of course be more difficult if it refers "too much" to the content of the namespace. Namespaces should be used to isolate UNRELATED names/symbols, not to keep a single enum, class or type declaration, as a general rule.

--
Mats

Just being curious.. Is it possible to the template class I posted above work with enums like I wanted so that you could make any enum as class's enum?

In other words, I would like to be able to do this (to somehow derive enum in a class):

Code:

---

enum states { buu };

class test_class {
public:
        typedef enum states t;
};

test_class::t sample = test_class::buu;

---

Is this possible?

What is the benefit over the namespace suggestion above? You are just making things more complicated for absolutely no benefit [unless you can give a benefit that you think is worth the extra complexity]. Why is putting an enum inside a class more beneficial?

--
Mats

Quote:

---

Originally Posted by matsp

What is the benefit over the namespace suggestion above? You are just making things more complicated for absolutely no benefit [unless you can give a benefit that you think is worth the extra complexity]. Why is putting an enum inside a class more beneficial?

--
Mats

---

Its because the communication betwen the server and client uses serialization (message classes) and I would like one particular class to have same enums and they could be accessed (written) this way: the_class::the_enum; (without writing them two times - once in a namespace and once in that class).

It makes more sense if you write some_message test; test.set_state(some_message::some_state) instead of test.set_state(client::some_state);

In that case, I would put the enum INSIDE the class, and also produce the serialization code in that class.

I don't know for sure if you can achieve this with templates...

--
Mats