C Structures

C structures (declared with struct) are one of the most important building blocks in C. They let you bundle related data into a single type—exactly what you need for records like a user profile, a network packet, or a game object.

Once you understand how struct types work—how members are laid out in memory, how initialization behaves, and how pointers/dot access differ—you can write safer, clearer C code. This guide focuses on those details and the gotchas that usually bite people.

As an Amazon Associate I earn from qualifying purchases.

What a C structure (struct) is and why it matters

A structure groups multiple fields under one name. Instead of tracking parallel variables, you define a single type, then use one variable of that type.

• Improves readability: the relationship between fields becomes explicit.
• Enables composition: structs can contain arrays, other structs, and pointers.
• Supports data-oriented design: you can pack related data together and pass it around as a unit.

Structures are also the foundation for many C “interfaces”: you pass a pointer to a struct, fill it, return status codes, and keep behavior predictable.

Prerequisites and mental model

You should be comfortable with basic C types (like int, double), pointers, and functions. For maximum clarity, keep this mental model in mind:

• A struct defines a type.
• A struct variable is a block of memory sized to hold all members (plus any padding).
• Member access depends on whether you have the struct itself or a pointer to it.

Defining a struct type

There are two common patterns for defining structs: define-and-declare together, or define the type then use it later. Here’s the define-and-declare form.

struct Person { int age; double height_m;
};

Now struct Person is a defined type. You can declare variables of it like:

struct Person p;

Forward declarations (useful for recursive types)

If you need pointers to a struct before the full definition is available (common for linked lists or trees), you can forward-declare.

struct Node; // forward declaration

struct Node { int value; struct Node *next;
};

Declaring variables of a struct type

You can declare multiple variables in one statement, and you can also use typedef to simplify type names.

struct Person a, b;

With typedef:

typedef struct Person { int age; double height_m;
} Person;

Then you declare variables as:

Person p;

Both styles are valid. Many codebases use typedef to reduce noise; others prefer explicit struct for clarity.

Accessing members: dot vs arrow

Member access depends on whether you’re working with the struct value or a pointer to it.

You have…	Use…	Example
A struct variable	dot (.)	p.age
A pointer to struct	arrow (->)	pp->age

If you prefer the pointer form, pp->age is equivalent to (*pp).age.

Common initialization patterns

Initialization is where many subtle bugs come from. In C, uninitialized local variables have indeterminate values, so you must initialize or use them carefully.

Zero initialization

For automatic storage (local variables), explicitly initialize:

struct Person p = {0};

This sets all fields to zero (or NULL for pointer members).

At global scope, the compiler initializes to zero automatically.

Designated initializers (recommended)

Designated initializers make code resilient when you add fields.

struct Person p = { .age = 29, .height_m = 1.78
};

Positional initialization

Positional initialization depends on member order:

struct Person p = {29, 1.78};

If you reorder members later, you can accidentally swap values. That’s why designated initializers are widely preferred.

Partial initialization

You can initialize a subset; remaining members become zero:

struct Person p = { .age = 30 };

Structs and memory layout

Understanding memory layout helps when you interface with hardware, serialize data, or deal with ABI boundaries.

Padding and alignment

Compilers may insert padding so members align efficiently. That means sizeof a struct might be larger than the sum of member sizes.

#include <stdio.h>

struct S { char c; // 1 byte int n; // usually aligned to 4 bytes
};

int main(void) { printf("sizeof(struct S)=%zu\n", sizeof(struct S)); return 0;
×
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Run a Free PC Scan →
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteFind the Right Drivers →
Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.
}

Exact results vary by target platform and ABI.

Calculate member offsets safely

Use offsetof from <stddef.h> when you truly need offsets:

#include <stddef.h>

size_t off = offsetof(struct Person, height_m);

This is safer than manually guessing layout.

Structs containing arrays and other structs

You can model complex data by composing structs.

Struct with an array member

struct Packet { unsigned char bytes[16]; unsigned int length;
};

Copy the struct with memcpy if you need raw copying, or copy fields explicitly if you want tighter control.

Nested structs

struct Vec2 { double x, y; };

struct Body { struct Vec2 position; struct Vec2 velocity; double mass;
};

Access nested fields with chained member access: body.position.x.

Passing structs to functions

How you pass a struct impacts performance and correctness. The main options are pass-by-value, pass-by-pointer, or pass-by-const-pointer.

Pass by value

This copies the entire struct. For small structs it may be fine; for larger ones it can be expensive.

void print_person(struct Person p) { printf("age=%d\n", p.age);
}

Pass by pointer (commonly used)

You avoid copying and you can modify the caller’s data.

void birthday(struct Person *p) { if (!p) return; p->age += 1;
}

Pass by const pointer (read-only)

Use const when the function must not modify the struct.

double bmi(const struct Person *p) { // read p->height_m etc. return 0.0;
}

Returning structs from functions

C allows returning structs by value. Modern compilers often optimize this efficiently, but you should still consider size.

struct Person make_person(int age, double h) { struct Person p = { .age = age, .height_m = h }; return p;
}

If you need to return optional results, you can return a status code and fill an output struct through a pointer.

int parse_person(const char s, struct Person out) { if (!s || !out) return 0; // parse... return 1;
}

Pointers to structs and dynamic allocation

When you allocate structs dynamically, you typically deal with pointers.

Allocate with malloc

#include <stdlib.h>

struct Person p = malloc(sizeof p);
if (!p) { // handle allocation failure
}

*p = (struct Person){ .age = 0, .height_m = 0.0 };

Using sizeof *p prevents type mismatches if you refactor later.

Common lifecycle gotcha

After free(p), the pointer becomes invalid. Don’t dereference it. Set it to NULL if you might reuse it:

free(p);
p = NULL;

Self-referential structs and linked data

Self-referential structs are patterns where a struct contains a pointer to the same struct type. This enables linked lists and trees.

struct ListNode { int value; struct ListNode *next;
};

struct ListNode *head = NULL;

Forward declarations (shown earlier) help when the struct definition must reference itself before completion.

Const-correctness with structs

Const works at the member-access level. Prefer const pointers for input parameters and const struct variables when you don’t intend to modify them.

void format_name(const struct Person p, char out, size_t out_sz) { // read-only: no p->age = ...
}

If you need to modify a member but not others, sometimes you’ll need to adjust design (e.g., separate “mutable state” from “immutable configuration”).

Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Support on Ko-Fi

Common mistakes and how to debug them

Most struct bugs aren’t “mysterious”—they’re predictable. Here are the ones you’ll see repeatedly.

Forgetting to initialize local structs

Symptom: random values, flaky behavior. Fix: initialize with ={0} or designated initializers.

struct Person p; // uninitialized
// p.age may contain garbage

Using the wrong member access operator

Symptom: compile errors or, worse, subtle casts. Fix: use . for struct variables and -> for pointers to structs.

Lifetime issues with pointers to stack structs

If you store a pointer to a local struct and return it, you get a dangling pointer.

const struct Person *bad(void) { struct Person p = { .age = 1, .height_m = 1.0 }; return &p; // p dies when function returns
}

Fix: allocate dynamically or return by value (or require the caller to provide storage).

Shallow copies with pointers inside structs

If your struct contains pointers, copying the struct copies pointer values, not the pointed-to data.

struct User { char *name; // points to heap or string literal
};

If you copy a User with User b = a;, both structs point to the same name. That’s fine if you manage ownership carefully—otherwise it causes double-frees or use-after-free.

Using memcmp/memcpy incorrectly for structs

memcpy is fine for copying raw bytes, but memcmp on structs with padding can compare uninitialized padding bytes. Prefer explicit field comparisons for correctness.

Alignment/padding mismatches when serializing

Binary serialization of raw structs is not portable across compilers/architectures because padding and endianness differ. Serialize field-by-field instead.

Checklist when something fails

• Compile with warnings: -Wall -Wextra -Wpedantic.
• Use sanitizers: -fsanitize=address,undefined (Clang/GCC).
• Print sizeof and offsets with sizeof and offsetof to confirm layout assumptions.
• For pointer bugs, confirm ownership and lifetime rules (who allocates and who frees).

Alternatives and when not to use structs

Structs are usually the right tool, but there are cases where alternatives fit better.

• Use separate variables when there’s no real grouping or when you want maximum compiler freedom for optimization.
• Use arrays of primitives (e.g., double x[N]) when you’re doing numeric loops and want tight data locality with less indirection. You can also use “struct of arrays” layouts.
• Use opaque pointers (e.g., typedef struct Foo Foo;) when you want to hide implementation details in a library.

FAQ: C structures

Can I define a struct inside a function in C?

Yes, you can define a struct type inside a function scope in C (depending on your C standard mode and compiler behavior). Many codebases still prefer global/type-level definitions for clarity.

What’s the difference between a struct and a typedef for a struct?

A struct defines the layout and members. A typedef just gives the type a convenient alias. The underlying type is still the struct.

Is assignment between structs a shallow or deep copy?

It’s a shallow copy at the byte/pointer level: all members are copied. If members include pointers, both struct instances will reference the same pointed-to memory unless you implement custom deep-copy logic.

Can I compare structs with == ?

In standard C, you generally can’t use == to compare structs directly. Compare relevant fields manually, or compare bytewise with memcmp only when the struct has no padding issues and padding bytes are well-defined (often hard to guarantee).

Do I need to zero-initialize structs before use?

For local (stack) variables, you should initialize before reading any field. If you fully assign every member before reading, zero-init may be unnecessary. For safety and maintainability, ={0} and designated initializers are common practices.

Bottom Line

C structures are the standard way to group related data in C. Once you’re consistent about initialization, member access (. vs ->), and pointer lifetimes, structs become a reliable foundation for real software.

If you treat struct variables as concrete memory objects and design your ownership rules clearly—especially when pointers live inside structs—you’ll avoid the majority of the bugs people associate with C in the first place.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.