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

Part1 : STL Algorithms (Non-Modifying sequence) in c++

Non-Modifying sequence operations : 1.  Non-modifying sequence operations:   _of (CPP 11) std::array all_of_elem = { 3,5,7,11,13,17,19,23 }; 1. if ( std::all_of ( all_of_elem.begin(),   all_of_elem.end() ,  [](int i) {return i % 2; } )) std::cout << "All the elements are odd numbers.\n"; std::array any_of_elem = { 0,1,-1,3,-3,5,-5 }; 2. if ( std::any_of ( any_of_elem.begin() ,  any_of_elem.end() ,  [](int i) {return i )) std::cout << "There are negative elements in the range.\n"; std::array foo = { 1,2,4,8,16,32,64,128 }; 3. if ( std::none_of ( foo.begin() ,  foo.end() ,  [](int i) {return i )) std::cout << "There are no negative elements in the range.\n"; 2.  Non-modifying sequence operations:   find       std::string myints[] = { "Hello", "Hi", "Bye", "ByeBye" }; std::vector myvector(myints, myints + 4); std::vector ::iterator it;...
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

Containers in c++

SEQUENTIAL CONTAINER Vector (Dynamic Array - Contiguous memory):  O(1): Vectors provide fast (constant time) element insertion and deletion at the end of the vector and Acess. O(n): Slow (linear time) insertion and deletion anywhere else. Insertion and deletion are slow because the operation must move all the elements “down” or “up” by one to make room for the new element or to fill the space left by the deleted element. Like arrays, vectors provide fast (constant time) access to any of their elements. List (Doubly Linked List - Not  Contiguous memory ): O(n): Lists provide slow (linear time) element lookup and access, O(1):  (constant time) insertion and deletion of elements once the relevant position has been found Deque (Doubly Ended Queue - Not Contiguous memory): O(1): (constant time) element access. Like a list, it provides fast (amortized constant time) insertion and deletion at both ends of the sequence. O(1):  (lin...
Post a Comment
Read more