Structure vs Union vs Class in C++

Syntax Comparison

// Structure
struct Student
{
    int rollNo;
    string name;
};

// Union
union Data
{
    int i;
    float f;
};

// Class
class Student
{
private:
    int rollNo;

public:
    void display()
    {
        cout << rollNo;
    }
};

One Program Demonstrating All Three

#include <iostream>
using namespace std;

// Structure
struct StudentStruct
{
    int rollNo;
};

// Union
union Data
{
    int i;
    float f;
};

// Class
class StudentClass
{
private:
    int rollNo;

public:
    void setRollNo(int r)
    {
        rollNo = r;
    }

    void display()
    {
        cout << "Class Roll No: " << rollNo << endl;
    }
};

int main()
{
    // Structure
    StudentStruct s;
    s.rollNo = 101;

    // Union
    Data d;
    d.i = 50;

    // Class
    StudentClass c;
    c.setRollNo(102);

    cout << "Structure Roll No: " << s.rollNo << endl;
    cout << "Union Integer: " << d.i << endl;
    c.display();

    return 0;
}

Output:

Structure Roll No: 101
Union Integer: 50
Class Roll No: 102

 Most Important Exam Points

One-line memory trick:
Structure = Grouping, Union = Memory Sharing, Class = Encapsulation + OOP.

Analysis of an Algorithm

Algorithm Analysis is the process of evaluating an algorithm to determine its efficiency in terms of time and memory requirements as the size of the input increases.

In Data Structures, algorithm analysis helps us to compare different algorithms and select the most efficient one for solving a particular problem.

1. Why do we analyse an algorithm?

Suppose we have two algorithms for searching an element:

• Algorithm A takes 10 seconds

• Algorithm B takes 1 second

Clearly, Algorithm B is more efficient. However, simply measuring execution time on one computer is not sufficient because execution time depends on:

• Processor speed

• Programming language

• Compiler

• Operating system

• Input data

• System load

Therefore, algorithms are generally analysed based on their growth rate with respect to input size.

2. Main Factors in Algorithm Analysis

There are mainly two factors:

Time Complexity

Time complexity describes how the running time of an algorithm grows as the input size n increases.

For example:

for(int i = 0; i < n; i++)
{
    cout << i;
}

The loop executes n times.

Therefore:

Time Complexity = O(n)

Space Complexity

Space complexity describes how much additional memory an algorithm requires as the input size increases.

For example:

int sum = 0;

for(int i = 0; i < n; i++)
{
    sum = sum + i;
}

Only a few variables are used irrespective of n.

Therefore:

Space Complexity = O(1)

3. Cases in Algorithm Analysis

An algorithm can be analysed in three cases:

For example, consider Linear Search:

Array: 10  20  30  40  50
Search: 10

If 10 is found at the first position:

Best Case = O(1)

If the required element is somewhere in the middle:

Average Case = O(n)

If the element is at the last position or absent:

Worst Case = O(n)

4. Asymptotic Notations

To express algorithm complexity, we commonly use:

Big-O Notation — O

Represents the upper bound, commonly used for describing worst-case growth.

Examples:

O(1)       Constant
O(log n)   Logarithmic
O(n)       Linear
O(n log n) Linearithmic
O(n²)      Quadratic
O(2ⁿ)      Exponential

Growth Order

From generally more efficient to less efficient:

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)

5. Simple Example

Consider:

void display(int A[], int n)
{
    for(int i = 0; i < n; i++)
    {
        cout << A[i] << " ";
    }
}

Here, the loop executes n times.

Therefore:

Time Complexity = O(n)

Only a constant number of extra variables are used.

Therefore:

Space Complexity = O(1)

In one line:

Analysis of an algorithm is the systematic study of its time and space requirements to determine its efficiency and scalability for different input sizes.

Data Structure Operations

Data Structure Operations are the basic operations performed on data elements to store, access, modify, and manage data efficiently. The common operations are insertion, deletion, traversal, searching, sorting, and merging.

1. Insertion

Insertion means adding a new data element to an existing data structure.

For example:

Before:  10  20  30
Insert:  40
After:   10  20  30  40

The position of insertion depends on the data structure. In an array, an element may be inserted at the beginning, middle, or end.

2. Deletion

Deletion means removing an existing element from a data structure.

Before:  10  20  30  40
Delete:  30
After:   10  20  40

After deletion, the remaining elements may need to be rearranged depending on the data structure.

3. Traversal

Traversal means visiting each element of a data structure systematically.

For an array:

int A[5] = {10, 20, 30, 40, 50};

for(int i = 0; i < 5; i++)
    cout << A[i] << " ";

Output:

10 20 30 40 50

Traversal is particularly important because many other operations, such as searching and displaying data, require traversal.

4. Searching

Searching means finding whether a particular element exists in the data structure and, if required, determining its position.

Example:

Data:    10  20  30  40  50
Search:  30
Result:  Element found at position 3

Common searching techniques include:

• Linear Search

• Binary Search

5. Sorting

Sorting means arranging data elements according to a specified order.

Ascending:

40  10  30  20
        ↓
10  20  30  40

Descending:

40  30  20  10

Common sorting algorithms are Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, and Quick Sort.

6. Merging

Merging means combining two data structures of the same or compatible type into a single structure.

List 1: 10  20  30
List 2: 40  50  60

Merged: 10  20  30  40  50  60

7. Updating

Updating means replacing or modifying the value of an existing element.

Before:  10  20  30
              ↓
           Change 20 to 25

After:   10  25  30

In short

The basic operations on data structures can be remembered as:

Insertion → Deletion → Traversal → Searching → Sorting → Merging → Updating

For an introductory Data Structures lecture, the first three—Insertion, Deletion, and Traversal—are especially important because they form the foundation for understanding arrays, linked lists, stacks, queues, and other data structures.

Elementary Data Organizations:

 In Data Structures, Elementary Data Organizations refers to the basic ways in which data elements are organized and represented in memory before studying more advanced structures such as stacks, queues, linked lists, trees, and graphs.

The main elementary data organizations are:

Simple Hierarchy

The concept can be understood as:

Data → Data Element → Field → Record → File

For example, consider a student database:

Student Data
     ↓
Student Record
     ↓
--------------------------------
| Roll No | Name | Branch | Marks |
--------------------------------
    ↓        ↓       ↓       ↓
  Field    Field   Field   Field

A record represents one student:

101    Gopal    CSE    85

A collection of such records forms a file:

101   Gopal    CSE    85
102   Rahul    CSE    78
103   Amit     ECE    82
104   Neha     CSE    91

In the context of Data Structures

Elementary Data Organizations are generally the fundamental/basic organization of data, such as:

1. Arrays

2. Records/Structures

3. Files

4. Lists

5. Basic relationships between data elements

These provide the foundation for more sophisticated data structures.

For teaching purposes, you can explain it in one line as:

Elementary Data Organization is the basic arrangement and representation of individual data elements, fields, records, and collections of records in a computer's memory.

If this term is appearing in your C/C++ Data Structures syllabus, I can also explain “Elementary Data Organization” exactly according to the syllabus, including Data Structures, Data Types, Data Representation, and Classification of Data Structures.

AIM:

Write a C program to develop a menu-driven Student Result Management System. The program should accept marks of students in multiple subjects, calculate total and percentage, determine pass/fail status and grade using decision-making statements, and display the result. Use functions for different operations and appropriate loops for repeated processing. Implement a menu using switch-case and provide an option to terminate the program.

void result()

{

    int m[5], i, total = 0;

    float per;

    printf("Enter marks of 5 subjects: ");

    for(i = 0; i < 5; i++) {

        scanf("%d", &m[i]);

        total += m[i];

    }

    per = total / 5.0;

    printf("Total = %d\nPercentage = %.2f\n", total, per);

    if(per >= 90)

        printf("Grade: A+\n");

    else if(per >= 75)

        printf("Grade: A\n");

    else if(per >= 60)

        printf("Grade: B\n");

    else if(per >= 40)

        printf("Grade: C\n");

    else

        printf("Result: Fail\n");

}

int main()

{

    int ch;

    do {

        printf("\n1. Enter Result\n2. Exit\nChoice: ");

        scanf("%d", &ch);

        switch(ch) {

            case 1: result(); break;

            case 2: printf("Exit"); break;

            default: printf("Invalid Choice");

        }

    } while(ch != 2);

    return 0;

}

Output :

Experiment 10

Aim

To develop C++ programs that randomly generate complex numbers using the previously designed Complex class, write two complex numbers per line in a file along with an arithmetic operator, and read the file line by line to perform the specified operation.

Objectives

• To use the previously designed Complex class.
• To generate random complex numbers.
• To perform file output and input operations.
• To store arithmetic operators along with complex numbers.
• To read and process data line by line.
• To perform arithmetic operations on Complex objects.

Theory

File handling allows data to be stored permanently rather than only in main memory. C++ provides:

• ofstream for writing to files.
• ifstream for reading from files.

In this experiment, each line contains two complex numbers and an arithmetic operator.

For example:

(4 + 3i) (2 + 1i) +

The second program reads each line and calculates:

(4 + 3i) + (2 + 1i)

Program 1: Generate and Store Complex Numbers

#include <iostream>

#include <fstream>

#include <cstdlib>

#include <ctime>

using namespace std;

class Complex {

    int r, i;

public:

    Complex(int x = 0, int y = 0) {

        r = x;

        i = y;

    }

    void write(ofstream &file) {

        file << "(" << r << " + " << i << "i)";

    }

};

int main() {

    ofstream file("complex.txt");

    srand(time(0));

    char op[] = {'+', '-', '*', '/'};

    for (int n = 0; n < 5; n++) {

        Complex a(rand() % 10, rand() % 10);

        Complex b(rand() % 10, rand() % 10);

        a.write(file);

        file << " " << op[rand() % 4] << " ";

        b.write(file);

        file << endl;

    }

    file.close();

    cout << "Complex numbers written to file.\n";

    return 0;

}

Program 2: Read File and Perform Operation

#include <iostream>

#include <fstream>

using namespace std;

class Complex {

    double r, i;

public:

    Complex(double x = 0, double y = 0) {

        r = x;

        i = y;

    }

    Complex operator+(Complex c) {

        return Complex(r + c.r, i + c.i);

    }

    Complex operator-(Complex c) {

        return Complex(r - c.r, i - c.i);

    }

    Complex operator*(Complex c) {

        return Complex(r*c.r - i*c.i,

                       r*c.i + i*c.r);

    }

    Complex operator/(Complex c) {

        double d = c.r*c.r + c.i*c.i;

        if (d == 0)

            throw "Division by zero";

        return Complex(

            (r*c.r + i*c.i) / d,

            (i*c.r - r*c.i) / d

        );

    }

    void display() {

        cout << "(" << r << " + " << i << "i)";

    }

};

int main() {

    ifstream file("complex.txt");

    double r1, i1, r2, i2;

    char ch, op;

    Complex result;

    while (file >> ch >> r1 >> ch >> i1 >> ch

                >> ch >> r2 >> ch >> i2 >> ch >> op) {

        Complex a(r1, i1), b(r2, i2);

        try {

            switch (op) {

                case '+':

                    result = a + b;

                    break;

                case '-':

                    result = a - b;

                    break;

                case '*':

                    result = a * b;

                    break;

                case '/':

                    result = a / b;

                    break;

            }

            a.display();

            cout << " " << op << " ";

            b.display();

            cout << " = ";

            result.display();

            cout << endl;

        }

        catch (const char *msg) {

            cout << "Exception: " << msg << endl;

        }

    }

    file.close();

    return 0;

}

Sample Output

Complex numbers written to file.

(4 + 3i) + (2 + 1i) = (6 + 4i)

(7 + 2i) - (3 + 5i) = (4 + -3i)

(2 + 4i) * (3 + 1i) = (2 + 14i)

(8 + 6i) / (2 + 2i) = (3.5 + -0.5i)

Result

Thus, complex numbers were successfully generated randomly, stored in a file along with arithmetic operators, read from the file, and processed using overloaded Complex class operators.