C++ struct vs class — The Only Difference That Matters (Plus Real Use Cases)

Hi everyone! I'm AlanWu, a junior high school C++ learner. When I first saw both struct and class in C++, I was confused. I thought struct was just a C thing — a bag of variables with no functions. But in C++, you can put methods, constructors, inheritance — everything — in a struct.

So what's the actual difference? Here's the one-sentence answer, plus practical guidance on when to use which.

My GitHub: https://github.com/Cn-Alanwu

---

The One-Sentence Difference

In C++, struct and class are identical in every way — except the default access level: struct members are public by default; class members are private by default.

That's it. Everything else — inheritance, constructors, destructors, member functions, templates, virtual functions — works exactly the same in both.

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

class C {
    int x;  // private by default
};

int main() {
    S s;
    s.x = 5;   // OK — public

    C c;
    // c.x = 5;  // ERROR — private
    return 0;
}

If you add public: to the class, the two become completely identical:

class C {
public:
    int x;  // now public — exactly like struct
};

---

The Inheritance Difference (Same Rule)

The same access rule applies to inheritance:

struct Base {};
struct Derived : Base {};  // public inheritance by default

class Base2 {};
class Derived2 : Base2 {};  // private inheritance by default

This means if you use class and forget to write public before the base class name, you get private inheritance — which is almost never what you want. It's a common beginner trap.

class Animal {
public:
    void eat() {}
};

// WRONG — private inheritance by default
class Dog : Animal {
};

int main() {
    Dog d;
    // d.eat();  // ERROR — eat() is private in Dog
    return 0;
}

// FIXED
class Dog : public Animal {
};

---

So When Do I Use Which?

After a year of C++, here's my personal rule — and it's not about the technical difference at all. It's about what you're communicating to other programmers.

Use struct when:

• It's a simple data container — just a bundle of related values
• All members can safely be public
• There's no invariant to protect (no rule like "age must be positive")
• Examples: a point (x, y), a configuration settings bundle, a return value from a function

struct Point {
    double x, y;
};

struct Config {
    int width;
    int height;
    bool fullscreen;
};

// struct is great for returning multiple values
struct SearchResult {
    bool found;
    int index;
    std::string message;
};

SearchResult find(const std::vector<int>& v, int target) {
    for (size_t i = 0; i < v.size(); i++) {
        if (v[i] == target) return {true, (int)i, "Found"};
    }
    return {false, -1, "Not found"};
}

Use class when:

• You want encapsulation — hiding internal data behind methods
• There's an invariant to protect (like "balance never goes below zero")
• You expect the internal representation to change later
• You're building something with behavior, not just data

class BankAccount {
private:
    double balance = 0.0;

public:
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    bool withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }

    double getBalance() const {
        return balance;
    }
};

---

Real Example from My Project: algorithmCombination

In my header-only algorithm library, I use struct and class side by side:

// struct — pure data, no invariants
template<typename T>
struct Pair {
    T first, second;
};

// class — has behavior, needs encapsulation
template<typename T>
class Stack {
private:
    std::vector<T> data;

public:
    void push(const T& val) {
        data.push_back(val);
    }

    T pop() {
        if (data.empty()) throw std::runtime_error("Stack is empty");
        T val = data.back();
        data.pop_back();
        return val;
    }

    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
};

The Pair is just two values glued together — struct. The Stack has rules (can't pop when empty) — class.

---

What About C Compatibility?

If you're writing a header that might be included in C code, use struct — C doesn't have class. But if you're writing pure C++ (which most of us are), C compatibility is rarely a concern.

// C-compatible
struct Point {
    double x, y;
};
// Works in both C and C++

// C++ only
class Point {
public:
    double x, y;
    double distance() const { return sqrt(x*x + y*y); }
};
// C can't use this — it has a member function

---

Summary Table

Feature	struct	class
Default member access	public	private
Default inheritance	public	private
Can have methods?	Yes	Yes
Can have constructors?	Yes	Yes
Can use virtual functions?	Yes	Yes
Can use templates?	Yes	Yes
Conventional use	Plain data bundles	Encapsulated objects

---

The Real Takeaway

Don't overthink this. If you're coming from C, struct feels natural for data. If you're coming from Java, class feels natural for everything. Both are correct — just be consistent.

In my projects, I follow this rule: if all members are public and there are no invariants, I use struct. If anything is private or needs protection logic, I use class. That's it.

The compiler doesn't care. But whoever reads your code six months later (including you) will appreciate the signal.

GitHub: https://github.com/Cn-Alanwu