GeezerVison

In the C programming language, struct (referring to a structure) is the keyword used to define a composite, a.k.a. record, data type – a named set of values that occupy a block of memory. It allows for the different values to be accessed via a single identifier, often a pointer. A struct can contain other data types, so it is used for mixed-data-type records. For example, a bank customer struct might contain fields for the customer's name, address, telephone number, and balance.

A struct occupies a contiguous block of memory, usually delimited (sized) by word-length boundaries. It corresponds to the similarly named feature available in some assemblers for Intel processors. Being a block of contiguous memory, each field within a struct is located at a certain fixed offset from the start.

The sizeof operator results in the number of bytes needed to store a particular struct, just as it does for a primitive data type. The alignment of particular fields in the struct (with respect to word boundaries) is implementation-specific and may include padding. Modern compilers typically support the #pragma pack directive, which sets the size in bytes for alignment.^[1]

The C struct feature was derived from the same-named concept in ALGOL 68.^[2]

The following simple example depicts declaring a struct named Foo, with two fields of types Type1 and Type2 respectively.

struct Foo {
    Type1 member1;
    Type2 member2;
};

The added name Foo is optional in some contexts.

Members may possibly be padded for memory alignment, and thus it is often recommended to order fields from largest to smallest size for efficient memory usage.

A function may directly return a struct, although this is often not efficient at run-time. Since C99, a struct may also end with a flexible array member.

Structs can be composed of other structs:

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

struct Birthday {
    char name[50];
    struct Date dob;
};

It is legal to declare an anonymous struct within a struct, but it cannot be named in C (as there is no notion of nested types, unlike C++ where nesting named structs is legal).

struct Person {
    char name[50];
    int age;
    struct {
        char city[50];
        int zip;
    } addr;
};

A struct containing a pointer to a struct of its own type is commonly used to build linked data structures:

struct LinkedList {
    void* item; // stores the current item
    struct LinkedList* next; // stores the next list, or NULL if nothing next
};

Circularly referencing between two structs must be done using a forward declaration and pointers:

struct B;

struct A {
    struct B* b;
};

struct B {
    struct A* a;
};

typedef struct Foo {
    Type1 member1;
    Type2 member2;
} Foo;

// struct Foo can now be referred to as 'Foo'
Foo foo;

Considering the struct declaration:

struct Point {
    int x;
    int y;
};

There are three ways to initialize a structure:

C89-style initializers are used when contiguous members may be given.^[4] For example:

struct Point a = { 1, 2 };

For non contiguous or out of order members list, the designated initializer style (introduced in C99) may be used.^[5] For example:

struct Point a = { .x = 1, .b = 2 };

// May initialize fields out of order too
struct Point b = { .y = 4, .x = -3 };

If an initializer is given or if the object is statically allocated, omitted elements are initialized to 0.

A third way of initializing a structure is to copy the value of an existing object of the same type. For example:

struct Point b = a;

The state of a struct can be copied to another instance. A compiler might use memcpy() to copy the bytes of the memory block.

struct Point a = { 1, 3 };
struct Point b;
b = a;

Structs may also use bit fields to allow fields to share the same storage units, but layouts are implementation-defined.

struct Properties {
    // three fields can be compactly packed in one byte
    unsigned char visible : 1; // a occupies 1 bit
    unsigned char color : 3; // b occupies 3 bits
    unsigned char size : 4; // c occupies 4 bits
};

Pointers can be used to refer to a struct by its address. This is useful for passing a struct to a function to avoid the overhead of copying the struct. The -> operator dereferences the pointer (left operand) and accesses the value of a struct member (right operand).

struct Point p = { 3, 7 };
int x = p.x;
p.x = 10;
struct Point* pp = &p;
x = pp->x;
pp->x = 8;

Functions may take a struct as a parameter by value, but this is expensive as it copies the entire struct. Meanwhile, passing it by pointer is often preferable as the size of a pointer is known (typically 4 or 8 bytes).

#include <stdio.h>

// a larger struct which may carry a lot of data
struct Student {
    char name[50];
    unsigned int id;
    unsigned int semester;
    float gpa;
};

// passing by value
void print_student(struct Student s) {
    printf("Name: %s, ID: %d, in semester %d, with GPA: %.2f\n", s.name, s.id, s.semester, s.gpa);
}

// passing by pointer
void print_student(struct Student* s) {
    printf("Name: %s, ID: %d, in semester %d, with GPA: %.2f\n", s->name, s->id, s->semester, s->gpa);
}

ALGOL 68^[2], Crystal (programming language),^[6] D,^[7] Go, Julia,^[8] Rust, Swift and Zig^[9] have structs.

• Bit field – Data structure that maps one or more adjacent bits
• Flexible array member – C language feature
• Passive data structure – Another term for record
• Union type – Data type that allows for values that are one of multiple different data types