Struct in C: Defining, Initializing, and Using Structures

An array holds many values of one type. A struct does the opposite: it holds a few values of different types and treats them as one thing. A point is an x and a y. An employee is a name, an id, and a salary. Without structs you would carry those around as three loose variables and hope you never mixed up whose salary was whose.

Declaring a Struct Type

A struct declaration names a tag and lists the members inside braces:

struct Point {
    int x;
    int y;
};

The semicolon after the closing brace is required - forgetting it is one of the most confusing error messages a C beginner will meet, because the compiler blames the next line.

This declares a type, not a variable. In C the type's full name is struct Point, with the keyword included:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p;
    p.x = 3;
    p.y = 4;

    printf("(%d, %d)\n", p.x, p.y);
    return 0;
}

Members are read and written with the dot operator, p.x. A struct variable is an ordinary variable: it lives on the stack, it can be assigned to another struct of the same type with =, and it disappears at the end of its scope.

Writing struct Point everywhere gets tiring, which is why almost all real C code wraps the declaration in a typedef so the type is simply Point.

Initializing a Struct

You can fill a struct at the moment you declare it. The positional form lists values in declaration order:

struct Point p = {3, 4};   // x = 3, y = 4

The designated initializer names each member instead, which is clearer and safer:

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee a = {101, "Ada", 92000.0};
    struct Employee b = {.name = "Grace", .id = 102, .salary = 105000.0};
    struct Employee blank = {0};

    printf("%d %s %.2f\n", a.id, a.name, a.salary);
    printf("%d %s %.2f\n", b.id, b.name, b.salary);
    printf("%d [%s] %.2f\n", blank.id, blank.name, blank.salary);
    return 0;
}

Three things worth noticing:

• The designated form can list members in any order, so adding or reordering a member later does not silently shift values into the wrong slots.
• Any member you leave out is zero-initialized - {0} is the idiomatic way to zero an entire struct.
• A char name[32] member is a real array inside the struct, so the string is stored in the struct itself, not somewhere else. That also means a.name = "Ada"; after the fact is illegal; you need strcpy (see string functions).

A struct with no initializer is uninitialized, and reading its members before writing them is undefined behavior. = {0} costs nothing and removes the whole category of bug.

Assigning and Comparing

Struct assignment copies every member:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point a = {1, 2};
    struct Point b = a;   // full copy

    b.x = 99;

    printf("a = (%d, %d)\n", a.x, a.y);
    printf("b = (%d, %d)\n", b.x, b.y);
    return 0;
}

a is untouched: b got its own copy. But note what C does not give you - there is no == for structs. if (a == b) will not compile. Comparing means comparing members:

if (a.x == b.x && a.y == b.y) { /* equal */ }

Do not reach for memcmp as a shortcut. Compilers insert invisible padding bytes between members for alignment, and those bytes can hold garbage, so two structs with identical members can compare unequal byte-for-byte.

Arrays of Structs

Because a struct is a type like any other, you can make an array of them - the standard way to hold a table of records.

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee staff[3] = {
        {101, "Ada",    92000.0},
        {102, "Grace",  105000.0},
        {103, "Alan",   87000.0},
    };

    int n = sizeof(staff) / sizeof(staff[0]);
    double total = 0.0;

    for (int i = 0; i < n; i++) {
        printf("%-3d %-8s %10.2f\n", staff[i].id, staff[i].name, staff[i].salary);
        total += staff[i].salary;
    }

    printf("Average: %.2f\n", total / n);
    return 0;
}

staff[i].salary reads as "element i, then its salary member" - indexing binds tighter than the dot, so no parentheses are needed.

Structs Are Copied Into Functions

This is the rule that catches people. When you pass a struct to a function, C copies it. The function works on its own private copy:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // changes the copy only
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // squared distance, no math.h needed
}

int main(void) {
    struct Point p = {3, 4};

    try_to_move(p);
    printf("after try_to_move: (%d, %d)\n", p.x, p.y);
    printf("squared distance: %.0f\n", distance_from_origin(p));
    return 0;
}

p is still (3, 4). Reading a struct by value, as distance_from_origin does, is perfectly fine and often the clearest choice for small structs. But if the function must change the caller's struct - or if the struct is large enough that copying it is wasteful - pass a pointer instead. That is the subject of structs and pointers.

Returning a struct by value works the same way and is completely legal:

struct Point make_point(int x, int y) {
    struct Point p = {x, y};
    return p;
}

Nested Structs

A struct member can itself be a struct. Chain the dots to reach inside:

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

struct Book {
    char title[64];
    struct Date published;
    int pages;
};

int main(void) {
    struct Book b = {
        .title = "The C Programming Language",
        .published = {.year = 1978, .month = 2, .day = 22},
        .pages = 228,
    };

    printf("%s (%d-%02d-%02d), %d pages\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

b.published.year walks in one level at a time. Nesting is how you build real data models in C - and the inner struct is stored inside the outer one, not pointed at, so the whole Book is one contiguous block of memory.

Size, Padding, and Member Order

sizeof tells you how big a struct is, and the answer is often larger than the sum of its members:

#include <stdio.h>

struct Wasteful {
    char  a;    // 1 byte
    int   b;    // 4 bytes
    char  c;    // 1 byte
};

struct Tidy {
    int   b;
    char  a;
    char  c;
};

int main(void) {
    printf("Wasteful: %zu bytes\n", sizeof(struct Wasteful));
    printf("Tidy:     %zu bytes\n", sizeof(struct Tidy));
    return 0;
}

On a typical machine Wasteful is 12 bytes and Tidy is 8, even though both hold the same three members. The compiler inserts padding so each member sits at an address its type likes - an int usually wants a multiple of 4. Grouping larger members before smaller ones tends to pack better.

This matters rarely (a million-element array, a network packet layout) and never for correctness of your own code. What it does explain is why sizeof surprises you, and why memcmp on structs is a bad idea.