Skip to main content

Enum class in c++ | C++ 11


C++ 3.0 : Unscoped Enum:
// unscoped enum:  
enum [identifier] [: type]  
{enum-list};   
    

Example:  //NonScoped enum :

 namespace NonScoped  
{  
    enum Enum { num1, num2, num3, num4 };  
  
    void EnumFunction(Enum n_enum)  
    {  
        if (n_enum == num1) 
        { /*...*/  
        }  
    }  
}  

 Casting Rules :

 1. In Unscoped enum an int is never implicitly convertible to an enum value.

 int account_num = 135692;  
Enum hand;  
hand = account_num; // error C2440: '=' : cannot convert from 'int' to 'Enum' 

 2. A cast is required to convert an int to a scoped or unscoped enumerator.

 hand = static_cast(account_num); // OK, but probably a bug!!! 
3. You can promote a unscoped enumerator to an integer value without a cast.

 int account_num = num3; //OK if num3 is in a unscoped enum 
Using implicit conversions in this way can lead to unintended side-effects. To help eliminate programming errors associated with unscoped enums, scoped enum values are strongly typed.

 C++ 11 : Scoped Enum / ENUM Class :
// scoped enum:  
enum [class|struct]   
[identifier] [: type]   
{enum-list}; 
Example: // scoped enum: 

 namespace Scoped  
{  
    enum class classEnaum { num1, num2, num3, num4 };  
  
    void enumFunction(classEnum c_enum)  
    {  
        if (c_enum == classEnum::num2) 
        { /*...*/}  
    }  
}  

 Casting Rules :

 1. In scoped enum an int is never implicitly convertible to an enum value.

            classEnaum hand;   
hand = num2;
int account_num = 135692;  
hand = account_num; // error C2440: '=' : cannot convert from 'int' to 'hand' 


2.  A cast is required to convert an int to a scoped or unscoped enumerator.

 hand = static_cast(account_num); // OK, but probably a bug!!!


3.  Scoped enumerators must be qualified by the enum type name (identifier) and cannot be implicitly converted

 account_num = classEnaum::num2; // error C2440: '=' : cannot convert from 'Suit' to 'int'  
    account_num = static_cast(classEnaum::num2); // OK 
Advantages:

 1. Cannot be implicitly converted (strongly typed)

 2. Enum classes have another advantages over old-style enums. You can have a forward declaration to a strongly typed enum, meaning that you can write code like:

 enum class Mood;

void assessMood (Mood m);
  
// later on:
enum class Mood { EXCITED, MOODY, BLUE };
Why forward declaration would this be useful? A forward declaration allows you to declare an enum type in the header file while putting specific values into the cpp file. This lets you change the list of possible enum values quite frequently without forcing all dependent files to recompile.
Labels:

Comments

Post a Comment

Popular posts from this blog

const used with functions

const used with functions : class Dog {    int age;    string name; public:    Dog() { age = 3; name = "dummy"; }         // const parameters and these are overloaded functions    void setAge(const int& a) { age = a; }    void setAge(int& a) { age = a; }         // Const return value    const string& getName() {return name;}         // const function and these are overloaded functions    void printDogName() const { cout << name << "const" << endl; }  // value of name can't be modified    void printDogName() { cout << getName() << " non-const" << endl; } }; int main() {    Dog d;    d.printDogName();        const Dog d2;    d2.printDogName();     }
Post a Comment
Read more

Structured Bindings

Returning multiple Values from function C++ 11 vs C++ 17 Returning compound objects Iterating over a compound collection Direct initialization Returning multiple Values from function C++ 11 vs C++ 17 :  C++ 11 (std::tie): std::tuple mytuple() {     char a = 'a';     int i = 123;     bool b = true;     return std::make_tuple(a, i, b);  // packing variable into tuple } To access return value using C++ 11, we would need something like: char a; int i; bool b; std::tie(a, i, b) = mytuple();  // unpacking tuple into variables Where the variables have to be defined before use and the types known in advance. C++ 17 : auto [a, i, b] = mytuple(); Returning compound objects :  This is the easy way to assign the individual parts of a compound type (such as a struct, pair etc) to different variables all in one go – and have the correct types automatically assigned. So let’s have a look at an ...
Post a Comment
Read more

POST 1 : std::thread in c++ | C++ 11

std::thread   C++  Thread support library std::thread. Threads enable programs to execute across several processor cores. Defined in header Class : thread Member types : native_handle_type Data Member  id    //represents the id of a thread (public member class) Member functions (constructor)    //constructs new thread object (public member function) (destructor)    //destructs the thread object, underlying thread must be joined or detached  (public member function) operator=    //moves the thread object  Observers  // Covered in NEXT POST Operations    // Covered in NEXT POST Constructor :   #include   void f1 ( int n ) { for ( int i = 0 ; i < 5 ; ++ i ) { std:: cout << "Thread 1 executing \n " ; ++ n ; std:: this_thread :: sleep_for ( std:: chrono :: milliseconds ( 10 ) ) ; ...
Post a Comment
Read more