Enumeration in C++ with Example.

Enumeration, commonly known as enum, is a powerful feature in C++ that allows programmers to define a set of named constants. Enums provide a way to represent a group of related values, making code more readable and maintainable. This article will explore the concept of enumeration in C++, covering its definition and example.

What is Enumeration?

Enumeration in C++ is a user-defined data type that consists of a set of named constants, known as enumerators. Enums allow us to define corresponding values, making our code more expressive and self-documenting. Let's understand with one example.

Example:

enum Color {
    RED,
    GREEN,
    BLUE
};

In this example, the enum "Color" represents different colors: RED, GREEN, and BLUE. By default, the enumerators are assigned integer values starting from 0, so RED will have a value of 0, GREEN will have a value of 1, and BLUE will have a value of 2.

Changing the Default value of the enum.

Enums in C++ assign default integer values starting from 0 for the first enumerator, 1 for the second, and so on. However, we can change these default values by explicitly assigning different values.

Example:

enum Color {
    RED = 1,
    GREEN,
    BLUE
};

In this example, we change the default values of the Color enum by explicitly assigning RED as 1. The subsequent enumerators will be assigned the next integer values sequentially.

Enumerated Type Declaration.

Enumerated type declarations in C++ allow you to create a new type based on an existing enum. This enhances code clarity and type safety. 

Example:

//C++ code example to Enumerated Type Declaration
#include <iostream>
using namespace std;

//declare enum
enum Weekday {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
};

typedef enum Weekday Day;

int main() {
    Day today = WEDNESDAY;

    cout << "Today is ";
    
    switch (today) {
        case MONDAY:
            cout << "Monday";
            break;
        case TUESDAY:
            cout << "Tuesday";
            break;
        case WEDNESDAY:
            cout << "Wednesday";
            break;
        case THURSDAY:
            cout << "Thursday";
            break;
        case FRIDAY:
            cout << "Friday";
            break;
        case SATURDAY:
            cout << "Saturday";
            break;
        case SUNDAY:
            cout << "Sunday";
            break;
        default:
            cout << "Invalid day";
            break;
    }
    cout << endl;
    return 0;
}

Output:

Today is Wednesday

In this example, we define an enum named "Weekday" with seven enumerators representing different days of the week. We then use the typedef keyword to create a new type "Day" based on the "Weekday" enum.

Inside the main() function, we declare a variable "today" of type "Day" and assign it the value "WEDNESDAY". This is possible because we created the "Day" type based on the "Weekday" enum.

We then use a switch statement to display the corresponding day based on the value of "today". Depending on the value of "today", the switch case will execute and output the corresponding day of the week.

How to use Enum for Flags?

Enums can be used to define flag values, where each enumerator represents a specific flag that can be combined using bitwise operators.

Example:

//C++ program for using enum for flag
#include <iostream>
using namespace std;

enum Permissions {
    READ = 1,
    WRITE = 2,
    EXECUTE = 4
};

int main() {
    // Combine READ and WRITE flags
    Permissions userPermissions = static_cast<Permissions>(READ | WRITE); 

    // Checking individual flags
    if (userPermissions & READ) {
        cout << "User has read permission" << endl;
    }

    if (userPermissions & WRITE) {
        cout << "User has write permission" << endl;
    }

    if (userPermissions & EXECUTE) {
        cout << "User has execute permission" << endl;
    }

    return 0;
}

Output:

User has read permission
User has write permission

Working:

In this example, we define an enum named "Permissions" with three enumerators: READ, WRITE, and EXECUTE. Each enumerator represents a specific permission or flag.

Inside the main() function, we declare a variable "userPermissions" of type "Permissions" and initialize it by combining the READ and WRITE flags using the bitwise OR operator (|).

To check individual flags, we use the bitwise AND operator (&) in combination with the respective flag to determine if the flag is set or not. If the result of the bitwise AND operation is non-zero, it means the flag is present.

In this case, we check if the user has read, written, and execute permissions by performing bitwise AND operations with the corresponding flags. If a flag is set, we output a message indicating that the user has that specific permission.

 

Why Enums are used in C++?

Enums are used in C++ programming for several reasons:

1. Enhancing code readability: Enums provide meaningful names to constants, making the code self-explanatory and easier to understand.

2. Type safety: Enums help prevent accidental assignment of incorrect values by restricting the variable to a specific set of named constants.

3. Improved maintainability: By using enums, code becomes more modular and less error-prone when changes or additions are required.

Enums offer clarity, type safety, and improved code organization, contributing to efficient and effective software development practices.

Understanding Unions in C++ with Example.

In C++, a union is a special data type that allows the storage of different data types in the same memory location. Unions provide a way to save memory by enabling variables to share memory space, which can be useful in certain programming scenarios. 

In this article we will explore the concept of unions in C++, covering their definition, and usage with examples, and highlighting the key differences between unions and structures.

What is a Union in C++?

A union in C++ is a user-defined data type that enables variables of different data types to share the same memory space. Unlike structures, where each member has its own memory allocation, union members overlap in memory. The size of a union is determined by the largest member within it.

Syntax:

union UnionName {
    // Member declarations
    DataType1 member1;
    DataType2 member2;
    // ...
};

Usage of Union in C++.

Unions are primarily used when you want to store different types of data in the same memory space, but only one member of the union can be active at any given time. This allows memory efficiency and can be handy in situations where you need to conserve memory or represent variant data.

Example Union Program in C++:

//C++ Program to show working on union
#include <iostream>
using namespace std;

//declare union
union NumericValue {
    int value1;
    float value2;
};

int main() {
    NumericValue value;
    value.value1 = 42;
    
    cout << "Integer Value: " << value.value1 << endl;
    
    value.value2 = 3.14;
    
    cout << "Float Value: " << value.value2 << endl;
    cout << "Integer Value after assigning float: " << value.value1 << endl;
    
    return 0;
}

Output:

Integer Value: 42
Float Value: 3.14
Integer Value after assigning float: 1078523331

In this example code, we have a union named NumericValue that contains two members: value1 of type int and value2 of type float. We will use this union to store either an integer or a float value in the same memory space.

In the main() function, we create an instance of the union named value. Initially, we assign the value 42 to value1 and print it as the "Integer Value." Since only the value1 member is active at this point, accessing it yields the expected result.

Next, we assign the value 3.14 to value2 and print it as the "Float Value." However, note that after assigning a value to value2, the value1 member is no longer valid, and accessing it results in undefined behavior.

To demonstrate this, we print the "Integer Value after assigning float" which may give an unexpected output due to the memory overlap. The output may vary depending on the system, compiler, and memory representation.

Note: Only one member can be active at any given time, sharing the memory space allocated for the union. Accessing a member other than the one currently active may result in undefined behavior. (alert-passed)

How it is different from structure?

The key difference between union and structure:

• In a structure, each member has its own memory allocation, and all members can be accessed independently. In contrast, a union allows different members to share the same memory space, but only one member can be active at any given time.

• Unions are most commonly used to conserve memory or represent variant data, whereas structures are used to group related data elements into a single entity.

• Accessing a member of a union that is not currently active can lead to unpredictable results or undefined behavior. It is the programmer's responsibility to keep track of the active member and ensure correct usage.

By understanding unions and their characteristics, you can leverage them effectively in your C++ programs to optimize memory usage and handle variant data requirements efficiently.

Structure in C++ Programming with Example.

In programming, we often get a situation in which we want to store a group of related data together as a single unit. We can use Array in C++ to store similar data types but what to use to store non-similar data together? 

In C++, structures provide a powerful tool for organizing related data elements into a single entity. They allow programmers to create user-defined data types, facilitating the representation of complex entities.

What is a Structure?

A structure is a user-defined data type in C++ that allows the grouping of different data elements of different types under a single name. It provides a convenient way to represent a complex entity by combining variables of various data types into a single unit.

How to create a Structure in C++?

In C++, a structure is created using the struct keyword followed by the structure name and a block of member declarations enclosed within curly braces. Each member declaration represents a variable of a specific data type. 

Syntax:

struct StructureName {
    // Member declarations
    DataType1 member1;
    DataType2 member2;
    // ...
};

Inside the curly braces {}, you declare the members of the structure. You can include multiple member declarations of different data types.

Structure in C++ can contain data members as well as member functions. Here's an example to illustrate this.

Example:

struct Rectangle {
    // Data members
    double length;
    double width;
    
    // Member function to calculate the area
    double calculateArea() {
        return length * width;
    }
};

In the above example, we define a struct named Rectangle that represents a rectangle shape. It contains two data members: length and width, which store the dimensions of the rectangle.

How to Declare and Initialize Structure Variables?

Once a structure is defined, variables of that structure type can be declared using the structure name followed by the variable name. Structure members can be initialized at the time of declaration using the dot (.) operator to access the member and assign it a value.

Example: 

int main(){
   //Declaration of structure variable
   Rectangle r1;
   r1.length = 5.0;
   r1.width = 3.0;

   Rectangle r2 {10.0, 9.0};
}

In the main() function, we create an instance of the Rectangle struct named rectangle. We assign values to its data members' length and width.

How to Access Structure Variable?

To access the elements of a structure variable, the dot (.) operator is used to access a specific member. 

Example:

//accessing members
cout << "Rectangle Length: " << r1.length << endl;
cout << "Rectangle Width: " << r1.width << endl;

Here is a complete working example of Structure using C++ programming.

//C++ Example Program to show working of structure
#include <iostream>
using namespace std;

struct Rectangle {
    // Data members
    double length;
    double width;
    
    // Member function to calculate the area
    double calculateArea() {
        return length * width;
    }
};

int main() {
    //declaring struct variable
    Rectangle r1;
    r1.length = 5.0;
    r1.width = 3.0;
    
    //Accessing structure elments
    cout<<"Rectangle Length: " << r1.length <<endl;
    cout<<"Rectangle Width: " <<r1.width <<endl;

    double area = r1.calculateArea();
    std::cout << "Area: " << area << std::endl;
    
    return 0;
}

Output:

Rectangle Length: 5
Rectangle Width: 3
Area: 15

As we can see in the above code, the struct contains both data members (length and width) and member functions calculateArea(). This allows us to encapsulate related data and behavior within a single struct, providing a convenient way to work with objects and perform operations on them.

What is an Array of Structures?

An array of structures allows the creation of multiple instances of a structure. It provides a convenient way to store and manipulate a collection of related data elements.

Example of Array Structure:

//C++ program to show working of Array Structure.
#include <iostream>
#include <string>
using namespace std;

struct Student {
    std::string name;
    int age;
    int rollNumber;
};

int main() {
    const int SIZE = 3;
    Student students[SIZE];

    // Populate the array of structures
    students[0] = { "John Doe", 18, 101 };
    students[1] = { "Jane Smith", 19, 102 };
    students[2] = { "Alice Johnson", 20, 103 };

    // Access and display the data
    for (int i = 0; i < SIZE; ++i) {
        cout << "Student #" << i + 1 << endl;
        cout << "Name: " << students[i].name << endl;
        cout << "Age: " << students[i].age << endl;
        cout << "Roll Number: " << students[i].rollNumber << endl;
        cout << endl;
    }

    return 0;
}

output:

Student #1
Name: John Doe
Age: 18
Roll Number: 101

Student #2
Name: Jane Smith
Age: 19
Roll Number: 102

Student #3
Name: Alice Johnson
Age: 20
Roll Number: 103

What is Structure Pointer?

A structure pointer is a pointer variable that points to a structure. It allows indirect access to the members of the structure using the arrow (->) operator.

Example of Structure Pointer:

//C++ Program to show working of structure pointer
#include <iostream>
#include <string>
using namespace std;

struct Person {
    std::string name;
    int age;
};

int main() {
    Person person;
    person.name = "John Doe";
    person.age = 30;

    // Create a structure pointer
    Person* personPtr = &person;

    // Access structure members using the arrow operator
    cout << "Name: " << personPtr->name << endl;
    cout << "Age: " << personPtr->age << endl;

    // Modify structure members using the arrow operator
    personPtr->name = "Jane Smith";
    personPtr->age = 25;

    // Access modified structure members
    cout << "Updated Name: " << person.name << endl;
    cout << "Updated Age: " << person.age << endl;

    return 0;
}

Output:

Name: John Doe
Age: 30
Updated Name: Jane Smith
Updated Age: 25

By using structure pointers, you can dynamically allocate memory for structures, pass structures to functions by reference, and efficiently access and modify structure members.

What is Structure Member Alignment?

Structure member alignment refers to the arrangement of structure members in memory. It ensures that each member is aligned according to its data type's memory requirements to optimize memory access and prevent memory alignment issues.

Learn more: Difference Between Structure and Class in C++.

Difference Between For and Foreach Loop in C++.

In C++, the for loop and the for-each loop (also known as range-based for loop) is used to iterate over a collection of elements. However, they have some differences in terms of syntax and functionality. Here's a comparison between the two:

What is for Loop?

The for loop is a control flow statement in programming languages that allows repetitive execution of a block of code based on a specified condition. It is commonly used when you know the number of iterations or want to iterate over a collection of elements.

Syntax: 

for (initialization; condition; increment/decrement) {
    // Code to be executed repeatedly
}

• Initialization: It initializes a counter variable or variables and sets their initial values. This step is executed only once before the loop starts.

• Condition: It checks the condition at the beginning of each iteration. If the condition evaluates to true, the loop continues executing; otherwise, the loop terminates.

• Increment/Decrement: It updates the counter variable(s) after each iteration. It can be used to increase or decrease the counter value.

What is for-each Loop?

The foreach loop allows you to iterate over a collection without explicitly managing the iteration variable or the collection's size. It automatically handles the iteration process, making the code more concise and readable.

Syntax:

foreach (element in collection) {
    // Code to be executed for each element
}

• element: It represents the current element being processed in each iteration of the loop. It can be a variable that you define to hold the value of each element.

• collection: It refers to the collection or array over which you want to iterate. It can be an array, list, set, or any other iterable data structure.

Difference Between For and Foreach Loop:

Features	For Loop	For-each Loop
Syntax	for (initialization; condition; update)	for (element: collection)
Iteration	Used when you know the number of iterations.	Used to iterate over all elements in a collection.
Collection Type	Can be used with any iterable collection.	Specifically designed for iterable collections.
Element Access	Access elements using indices or iterators.	Directly access each element of the collection.
Control Over Iteration	Allows explicit control over initialization and update.	Automatic iteration over each element.
Loop Variables	Can declare loop variables inside the loop.	The loop variable is implicitly declared within the loop.
Modifying Collection	Can modify the collection during iteration.	Not suitable for modifying the collection during iteration.

1. Iteration.

For loop: The for loop is typically used when you need to iterate a fixed number of times. It allows you to specify the initialization, condition, and update expressions explicitly.

For-each loop: The for-each loop is used when you want to iterate over all the elements in a collection. It automatically iterates over each element without the need for an explicit initialization, condition, or update.

2. Collection type.

For loop: The for loop can be used with any iterable collection, such as arrays or containers like vectors, lists, etc.

For-each loop: The for-each loop is specifically designed for iterating over iterable collections like arrays, vectors, lists, etc.

3. Element access.

For loop: In a for loop, you usually access elements using array indices or iterators.

For-each loop: In a for-each loop, you directly access each element of the collection using a variable.

C++ Example code for For and Foreach Loop.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // Example using a for loop
    for (int i = 0; i < 5; i++) {
        cout << i << " ";
    }
    cout << endl;

    // Example using a for-each loop with a vector
    vector<int> numbers = {1, 2, 3, 4, 5};
    for (int num : numbers) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

Output:

0 1 2 3 4
1 2 3 4 5

In the above example, the for loop is used to iterate from 0 to 4, printing the loop variable i. On the other hand, the for-each loop iterates over each element in the numbers vector, printing each element.

Conclusion:

It's important to note that both loops have their own strengths and should be used based on the specific requirements of your program. The for loop provides more control and flexibility over the iteration process, while the for-each loop offers simplicity and ease of use when iterating over collections.

Difference Between Structure and Class in C++

In C++, both structures and classes are used to define custom data types that can hold multiple data members and member functions. While they share some similarities, there are a few key differences between structures and classes. Here in this article, we are going to understand the key differences between them and which one we should use in which conditions. But before discussing the difference we should have the basic idea of structure and class in C++.

What is Structure in C++?

In C++, a structure is a user-defined data type that allows you to group related data elements together. It provides a way to create a composite data structure that can hold multiple variables of different types. 

Structure Syntax:

struct StructureName {
    // Member declarations
    DataType1 member1;
    DataType2 member2;
    // ...
};

The struct keyword is used to define a structure and StructureName is the name given to the structure. Inside the curly braces {} you declare the member of the structure.

What is Class in C++?

In C++, a class is a user-defined data type that encapsulates data and functions together. It provides a blueprint for creating objects and defines their behavior and properties.

Class Syntax:

class ClassName {
    // Member declarations
    AccessSpecifier1:
        DataType1 member1;
        DataType2 member2;
        // ...

    AccessSpecifier2:
        FunctionReturnType functionName1(ParameterList);
        FunctionReturnType functionName2(ParameterList);
        // ...
};

The class keyword is used to define a Class and the ClassName is the name given to the class. Inside the curly braces {}, you declare the members of the class. Members can include data members (variables) and member functions (methods). AccessSpecifier is to determine the accessibility of the members within the class.  

Difference Between Structure and Class.

While they have some similarities, there are a few key differences between structures and classes and we are going to discuss each of them in detail.

Structure	Class
Members are public by default.	Members are private by default.
Structure does not support inheritance.	A class supports single and multiple inheritances.
Does not have access specifiers (private, protected).	Access specifiers can be used (public, private, protected).
A structure cannot have member functions.	A class can have member functions.
A structure cannot have constructors or destructors.	A class can have constructors and destructors.
Memory is allocated for each instance separately.	Memory is allocated once and shared among instances.
Used for simple data structures or data containers.	Used for complex objects with behavior and properties.

1. Default Member Accessibility.

In a structure, by default, all members (data and functions) are public. This means that they can be accessed from outside the structure without any restrictions. 

C++ Structure Example Code:

//C++ code Structure default Accessibility
#include <iostream>
using namespace std;

// Define a structure named Point
struct Point {
    int x;
    int y;
};

int main() {
    // Declare a variable of type Point
    Point p1;

    // Access and assign values to the members
    p1.x = 10;
    p1.y = 20;

    // Display the values of the members
    cout << "x: " << p1.x << endl;
    cout << "y: " << p1.y << endl;

    return 0;
}

Output:

x: 10
y: 20

In contrast, in a class, by default, all members are private. This means that they can only be accessed within the class itself and its friend functions.

C++ Class Example Code:

//C++ code class defualt Accessibility
#include <iostream>
using namespace std;

// Define a class named Point
class Point {
    //private by default
    int x;
    int y;
};

int main() {
    // Declare a variable of type Point
    Point p1;

    //Error because members are private
    p1.x = 10;
    p1.y = 20;

    // Display the values of the members
    cout << "x: " << p1.x << endl;
    cout << "y: " << p1.y << endl;

    return 0;
}

Output:

2. Inheritance.

In C++, classes support inheritance, which is the ability to derive new classes from existing ones. Inheritance allows for code reuse and the creation of hierarchical relationships between classes. Structures, on the other hand, do not support inheritance by default. Although you can technically use inheritance with structures, it is more common to use classes for that purpose.

3. Object-Oriented Features.

Classes are primarily used in object-oriented programming (OOP) and provide features like encapsulation, data hiding, and polymorphism. They are suitable for creating complex data types with associated behaviors. Structures, on the other hand, are traditionally used for simple data structures that group related data together. They do not support advanced OOP features like inheritance and access specifiers.

When to use Structure in C++?

• When you need a simple data container to group related data together, such as representing a point with x and y coordinates.

• When you want all members to be public by default, without the need for strict encapsulation.

• When you don't need to use advanced OOP features like inheritance and access specifiers.

When to use Class in C++?

• When you want to create complex data types with associated behaviors and encapsulation.

• When you need to define private members and provide controlled access through member functions.

• When you want to use inheritance to derive new classes and establish hierarchical relationships.

It's important to note that while structures and classes have some differences in their default behavior, you can often achieve similar functionality using either of them.

Difference Between #include ‹filename› and #include 'filename'

In C++, the #include directive is used to include header files in a program. There are two common ways to include header files: using angle brackets (< >) and using double quotes (" "). The difference between #include <filename> and #include "filename" lies in the way the compiler searches for the header file.

#include <filename>

When you use angle brackets, the compiler searches for the header file in the standard system directories. These directories contain the standard library headers and other system-specific headers. Typically, these headers are not part of your program's source code but are provided by the compiler or the system.

Example Code:

#include <iostream>

int main() {
    std::cout << "Hello, world!" << std::endl;
    return 0;
}

In this example, #include <iostream> is used to include the standard input/output stream header file. The compiler knows where to find this file in the standard system directories.

#include "filename"

When you use double quotes, the compiler searches for the header file in the current directory or the directory specified by the -I flag (include directory) during compilation. This method is typically used for including user-defined header files or headers located within the project directory.

Example:

Suppose you are working on a C++ project that involves creating a game. You have a file called "game.h" that contains the declarations of classes, functions, and variables specific to your game. In order to use these declarations in your main program file, you would include the "game.h" header file using double quotes.

How does #include ‹bits/stdc++.h› work in C++?

The #include <bits/stdc++.h> is a preprocessor directive commonly used in C++ programming to include a large set of standard library headers in a single line. It is not a standard header provided by the C++ Standard Library, but rather a non-standard header specific to certain compilers, such as the GNU C++ compiler (g++).

When you include <bits/stdc++.h>, it includes a collection of commonly used standard library headers, such as <iostream>, <vector>, <algorithm>, <string>, and more. It saves you from manually including multiple individual headers that you might need for your program.

Here's an example of how to use #include <bits/stdc++.h> in a C++ program:

//C++ code Implementation
#include <bits/stdc++.h>

int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5};
    //sorting the array
    std::sort(numbers.begin(), numbers.end());

    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Output

1 1 2 3 4 5 5 6 9

In this example, we use #include <bits/stdc++.h> at the beginning of the program. This single line effectively includes all the necessary standard library headers for our program. We then proceed to use various standard library features, such as std::vector, std::sort, and std::cout, without explicitly including their individual headers.

Advantages of using <bits/stdc++.h>:

Including <bits/stdc++.h> allows you to include a large set of commonly used standard library headers in a single line. It saves you from the hassle of including multiple individual headers manually. (alert-success)

With <bits/stdc++.h>, you don't need to spend time figuring out and including the specific headers you need for your program. It provides a quick way to get started with coding and prototyping. (alert-success)

<bits/stdc++.h> is supported by some popular compilers, such as the GNU C++ compiler (g++). If you are using a compiler that supports it, you can rely on the convenience of including a comprehensive set of headers without worrying about portability issues. (alert-success)

 

Disadvantages of using <bits/stdc++.h>:

<bits/stdc++.h> is not a standard C++ header. It is a non-standard header specific to certain compilers. This means that it may not be available or supported by all compilers. Using non-standard headers can make your code less portable and dependent on specific compiler implementations. (alert-error)

Including <bits/stdc++.h> pulls in a large number of headers, many of which you may not need for your specific program. This can increase the compilation time of your code unnecessarily, as the compiler needs to process and parse all the included headers. (alert-error) 

<bits/stdc++.h> includes a wide range of headers, potentially introducing a lot of names into the global namespace. This can lead to naming conflicts and make the code less readable. It is generally considered good practice to explicitly include only the headers you need to avoid polluting the namespace. (alert-error)

It is worth noting that the use of #includes <bits/stdc++.h> is not recommended in professional or production code because it is not a standardized header and may not be supported by all compilers. It is more common to include the specific headers you need for your program, as it provides better control over the dependencies and improves code portability.