When should you use a class vs a struct in C++?

 

In C++, the choice between using a class or a struct primarily depends on the intended use and the nature of the data structure you want to create. Both classes and structs in C++ can be used to define custom data types, but there are some key differences between them:

1. Accessibility:

   • In a class, members (variables and functions) are private by default, which means they are not accessible from outside the class without appropriate accessors or mutators.
   • In a struct, members are public by default, which means they can be accessed directly from outside the struct.

2. Purpose:

   • Classes are typically used to encapsulate data and behavior (methods) into a single unit, following the principles of encapsulation, data hiding, and abstraction. Classes are often used to create objects with private data and controlled access to that data.
   • Structs are usually used for simple data containers with public access, such as a group of related variables. They are often used when you want a lightweight data structure without encapsulation or methods.

Here's an example to illustrate when to use a class and when to use a struct:

Using a Class (Encapsulation and Data Hiding):

cpp

class Person {
private:
    std::string name;
    int age;

public:
    // Constructor
    Person(std::string n, int a) : name(n), age(a) {}

    // Getter methods
    std::string getName() const {
        return name;
    }

    int getAge() const {
        return age;
    }

    // Setter methods
    void setName(std::string n) {
        name = n;
    }

    void setAge(int a) {
        age = a;
    }
};

In this example, we use a class Person to encapsulate the data (name and age) and provide getter and setter methods to access and modify the data. This allows for better control over the data and follows the principles of encapsulation.

Using a Struct (Simple Data Container):

cpp

struct Point {
    int x;
    int y;
};

int main() {
    Point p1 = {1, 2};
    Point p2 = {3, 4};

    // Accessing struct members directly
    int sum = p1.x + p2.x;
    
    return 0;
}

In this example, we use a struct Point to create a simple data container with two public integer members x and y. Structs are often used for lightweight data structures where direct access to members is desirable.

In summary, you should use a class when you need encapsulation, data hiding, and behavior associated with your data. On the other hand, you should use a struct when you want a simple data container or when you prefer direct access to members without encapsulation. The choice between class and struct should align with the design goals of your program and the intended use of the data structure.