C++ Structs: Group Related Data Into One Type

Why Group Data Together

So far every variable has stood on its own: an int here, a string there. But real programs deal with things made of several pieces - a point has an x and a y, a student has a name, an age, and a GPA. Passing those around as loose, separate variables is error-prone; nothing ties them together, and a function that needs all three must take all three parameters.

A struct fixes this. It defines a new type that bundles related variables - its members - into one unit. Once defined, you treat the whole bundle as a single value you can store, copy, and pass to functions.

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

struct Student {
    string name;
    int age;
    double gpa;
};   // <- don't forget the semicolon after the closing brace

int main() {
    Student s;          // one object holding all three members
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

    cout << s.name << " is " << s.age << " (GPA " << s.gpa << ")\n";
}

You reach each member with the dot operator (s.name, s.age). The semicolon after the closing } of a struct definition is required - leaving it off is one of the most common beginner compile errors in C++.

Initializing a Struct

Assigning each field by hand works, but it's verbose and easy to forget a member. The cleaner option is aggregate initialization: list the values in braces, in the same order the members were declared.

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (brace init, preferred)
    Point origin{};       // both members value-initialized to 0
    Point b = {10, 20};   // older = {} form, identical effect

    cout << a.x << "," << a.y << "\n";          // 3,4
    cout << origin.x << "," << origin.y << "\n"; // 0,0
    cout << b.x << "," << b.y << "\n";           // 10,20
}

Watch out for the empty default: Point p; (no braces) leaves x and y holding garbage values, because built-in members aren't auto-zeroed. Point p{}; value-initializes them to 0. Prefer the braces. You can also bake in defaults right in the definition, so even Point p; starts clean:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // default member initializers
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // uses every default
    Config wide{1920};    // width overridden, others keep defaults

    cout << c.width << "x" << c.height << "\n";        // 800x600
    cout << wide.width << "x" << wide.height << "\n";  // 1920x600
}

Structs as Function Parameters

A struct is a single value, so a function can take one parameter instead of three. Just remember that passing a struct by value copies every member. For anything bigger than a couple of ints, pass by const reference to skip the copy - the same rule you saw on the references page.

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

struct Student {
    string name;
    double gpa;
};

// const& avoids copying the string, and promises not to modify s
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// returning a struct is fine - the compiler optimizes the copy away
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

int main() {
    Student top = makeStudent("Grace", 4.0);
    printStudent(top);
}

Returning a whole struct from a function is the idiomatic way to hand back several values at once - far cleaner than juggling multiple output references.

Adding Member Functions and Constructors

A struct isn't limited to data. It can hold member functions that operate on its own members, and a constructor that initializes the object the moment it's created. This is where a struct starts to look like a small object with behavior.

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // constructor: runs when a Rectangle is created
    Rectangle(double w, double h) : width(w), height(h) {}

    // member function: uses the object's own members
    double area() const {        // const = "I don't modify the object"
        return width * height;
    }
};

int main() {
    Rectangle r(4.0, 5.0);
    cout << "area = " << r.area() << "\n";   // area = 20
}

Inside a member function the members are accessed by name (width, height) - they refer to this object's copy. Marking area() const tells the compiler the function only reads the object, which lets you call it on const Rectangle values too. Constructors are a topic in their own right, including that : width(w) initializer-list syntax - the constructors page goes deep.

Struct vs. Class: The Real Difference

You may have heard that "structs are for data, classes are for objects." That's a convention, not a language rule. In C++ a struct and a class are almost the same thing - the only built-in difference is the default access level.

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

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

Members of a struct are public unless you mark them otherwise; members of a class start out private. That's it - both can have constructors, member functions, inheritance, and everything else. You can even add explicit access specifiers to a struct to hide members:

#include <iostream>
using namespace std;

struct Counter {
    int value() const { return count; }   // public
    void bump() { count++; }

private:
    int count = 0;                          // now hidden
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // compile error - count is private
}

The practical takeaway: use struct for transparent bundles of data where every field is meant to be touched freely (a Point, a Color, a config record), and reach for class when you want to protect internal state behind a public interface. The compiler treats them the same; the keyword just signals your intent.

Arrays and Vectors of Structs

Because a struct is an ordinary type, you can put many of them in an array or a vector and loop over them like any other value.

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

struct Product {
    string name;
    double price;
};

int main() {
    vector<Product> cart = {
        {"Keyboard", 49.99},
        {"Mouse", 19.99},
        {"Monitor", 199.00},
    };

    double total = 0;
    for (const Product& p : cart) {   // const& - no copy per item
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

Note the nested braces: each {"Keyboard", 49.99} aggregate-initializes one Product, and the outer braces build the vector. Using const Product& in the range-based loop avoids copying each struct on every iteration - drop the & and you'd duplicate every element needlessly.

Next: Enums

Structs let you build a type out of several values bundled together. The next chapter goes the other direction: an enum defines a type that can hold exactly one value out of a small, named set - perfect for things like Color::Red, Direction::North, or a state machine's status. You'll see how enum class gives you readable, type-safe constants that pair naturally with the structs and classes you're now building.