C++ Structures vs Classes

Introduction

In C++, both structures (struct) and classes (class) are user-defined data types that allow you to group variables and functions under a single name. They are similar in many ways but have some key differences in terms of default access control and intended usage. Understanding these differences can help you choose the appropriate one for your needs.

Similarities Between Structures and Classes

1. Data Members: Both structures and classes can contain data members (variables).
2. Member Functions: Both can contain member functions (methods) to manipulate the data.
3. Access Specifiers: Both support access specifiers (public, private, and protected) to control access to their members.
4. Inheritance: Both can be used as base classes and can be inherited by other structures or classes.
5. Constructors and Destructors: Both can have constructors and destructors for initializing and cleaning up objects.

Differences Between Structures and Classes

1. Default Access Control

• Structures: The members of a structure are public by default.
• Classes: The members of a class are private by default.

Example: Default Access Control

#include <iostream>
using namespace std;

struct StructExample {
    int x; // public by default
};

class ClassExample {
    int y; // private by default
public:
    void setY(int value) {
        y = value;
    }
    int getY() {
        return y;
    }
};

int main() {
    StructExample s;
    s.x = 10; // Direct access is allowed
    cout << "StructExample x: " << s.x << endl;

    ClassExample c;
    // c.y = 20; // Direct access is not allowed (uncommenting this line will cause a compilation error)
    c.setY(20); // Access through public member function
    cout << "ClassExample y: " << c.getY() << endl;

    return 0;
}

Output

StructExample x: 10
ClassExample y: 20

Explanation

• In StructExample, x is public by default and can be accessed directly.
• In ClassExample, y is private by default and can only be accessed through public member functions.

2. Intended Usage

• Structures: Traditionally used for grouping related data. They are simpler and more suited for data-only structures.
• Classes: Typically used for more complex data structures that include both data and functions. They are better suited for implementing encapsulation and object-oriented features.

Example: Intended Usage

#include <iostream>
using namespace std;

// Structure for grouping related data
struct Point {
    int x;
    int y;
};

// Class for more complex data structure with functions
class Rectangle {
    int width;
    int height;
public:
    Rectangle(int w, int h) : width(w), height(h) {}
    int area() {
        return width * height;
    }
};

int main() {
    Point p = {3, 4};
    cout << "Point: (" << p.x << ", " << p.y << ")" << endl;

    Rectangle rect(5, 10);
    cout << "Rectangle area: " << rect.area() << endl;

    return 0;
}

Output

Point: (3, 4)
Rectangle area: 50

Explanation

• The Point structure is used to group related data (coordinates).
• The Rectangle class includes both data (width and height) and functions (area calculation).

Practical Examples

Example 1: Structure vs. Class for Simple Data Grouping

#include <iostream>
using namespace std;

struct EmployeeStruct {
    string name;
    int id;
    double salary;
};

class EmployeeClass {
    string name;
    int id;
    double salary;
public:
    void setData(string n, int i, double s) {
        name = n;
        id = i;
        salary = s;
    }
    void display() {
        cout << "Name: " << name << ", ID: " << id << ", Salary: " << salary << endl;
    }
};

int main() {
    EmployeeStruct empStruct = {"John Doe", 101, 50000};
    cout << "EmployeeStruct - Name: " << empStruct.name << ", ID: " << empStruct.id << ", Salary: " << empStruct.salary << endl;

    EmployeeClass empClass;
    empClass.setData("Jane Smith", 102, 60000);
    empClass.display();

    return 0;
}

Output

EmployeeStruct - Name: John Doe, ID: 101, Salary: 50000
Name: Jane Smith, ID: 102, Salary: 60000

Explanation

• EmployeeStruct is used to group related data and allows direct access to its members.
• EmployeeClass provides controlled access to its data through public member functions.

Example 2: Structure vs. Class with Inheritance

#include <iostream>
using namespace std;

struct BaseStruct {
    int a;
};

struct DerivedStruct : BaseStruct {
    int b;
};

class BaseClass {
    int a;
public:
    void setA(int value) {
        a = value;
    }
    int getA() {
        return a;
    }
};

class DerivedClass : public BaseClass {
    int b;
public:
    void setB(int value) {
        b = value;
    }
    int getB() {
        return b;
    }
};

int main() {
    DerivedStruct ds;
    ds.a = 10;
    ds.b = 20;
    cout << "DerivedStruct - a: " << ds.a << ", b: " << ds.b << endl;

    DerivedClass dc;
    dc.setA(30);
    dc.setB(40);
    cout << "DerivedClass - a: " << dc.getA() << ", b: " << dc.getB() << endl;

    return 0;
}

Output

DerivedStruct - a: 10, b: 20
DerivedClass - a: 30, b: 40

Explanation

• DerivedStruct inherits from BaseStruct and allows direct access to its members.
• DerivedClass inherits from BaseClass and provides controlled access to its members through public member functions.

Conclusion

While structures and classes in C++ share many similarities, they have different default access controls and intended uses. Structures are simpler and traditionally used for grouping related data, while classes are more suited for complex data structures with encapsulation and member functions. Understanding these differences helps you choose the appropriate one for your specific needs, whether it’s for simple data grouping or implementing more complex object-oriented designs.