struct: Grouping Fields That Belong Together

Maria keeps her shop's products in three arrays: names, prices and stock. Box 0 of each is rice, box 1 is oil, and only Maria's care keeps them in step.

One evening she sorts the names into alphabetical order and forgets to move the prices. The list now says oil costs 65 taka, and the first customer who buys oil gets a very good day.

This lesson gives Maria one variable per product, holding all three values, so they can only move together.

A struct keeps one record's fields together

Here are the three arrays before and after her sort, one row per index.

Nothing in C ties names[1] to prices[1]; they sit side by side only because Maria keeps them there. A name, a price and a stock count for one product are one record. A record should be one variable.

C gives you that with a structure, written struct. It is a type you design, grouping several values that each have a name and a type. Each value inside is a field; the C standard calls it a member.

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

#include <stdio.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

int main(void)
{
    struct product rice = { "rice", 65, 40 };

    printf("%s: %d taka, %d in stock\n", rice.name, rice.price, rice.stock);
    return 0;
}

rice: 65 taka, 40 in stock

The definition sits above main, so every function in the file can use the type. It makes no variable and sets aside no memory. It describes a shape, like a blank form with three labelled boxes.

The line in main makes a variable rice of type struct product; the type's name is both words. The braces hold an initialiser, the starting values of the fields.

To reach one field, write the variable, a dot and the field's name. This is the dot operator: rice.price reads aloud as "the price field of rice", and it is an ordinary int.

So a struct definition describes the shape once, and each variable of that type is one whole record.

Initialisers: by position, by name, and the zero rule

The braces in { "rice", 65, 40 } fill the fields in the order they were declared. That is a positional initialiser: short, but you must remember the order.

A designated initialiser names each field with a dot: { .price = 180, .name = "oil" }. The order stops mattering, and a reader sees which value goes where. Module 9 lesson 1 did the same for an array's boxes.

The zero rule carries over from arrays too: a field you leave out starts at zero. A number becomes 0, and a char array an empty string. This track writes = { 0 } to start a whole record at zero. Maria tries all four forms.

#include <stdio.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

int main(void)
{
    struct product rice = { "rice", 65, 40 };
    struct product oil = { .price = 180, .name = "oil" };
    struct product salt = { "salt" };
    struct product blank = { 0 };

    printf("%s %d %d\n", rice.name, rice.price, rice.stock);
    printf("%s %d %d\n", oil.name, oil.price, oil.stock);
    printf("%s %d %d\n", salt.name, salt.price, salt.stock);
    printf("[%s] %d %d\n", blank.name, blank.price, blank.stock);
    return 0;
}

rice 65 40
oil 180 0
salt 0 0
[] 0 0

oil got no stock, so its stock is 0. salt got only a name, so its price and stock are 0. The brackets frame the empty name of blank.

No message on the Playground or with -Wall. -Wextra warns about salt only: warning: missing initializer for field 'price' of 'struct product' [-Wmissing-field-initializers]. A short positional list may be a slip, so GCC asks. { 0 } and the designated oil say what they mean, and get no warning.

So a field you leave out starts at zero, and a designated initialiser names the fields in any order.

The dot writes fields, and scanf fills them

The dot also works on the left of =: item.price = item.price + 5; reads one field, adds 5 and writes it back. The other fields do not move.

scanf needs the address of every box it fills (Module 3, lesson 4). For an int field that is &item.price: the dot goes first, so & takes the address of that one field.

The name field takes no &, because an array's name in an expression is already an address (Module 11, lesson 3). The 19 in %19s leaves room for the zero (Module 10, lesson 3).

#include <stdio.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

int main(void)
{
    struct product item = { 0 };

    scanf("%19s %d %d", item.name, &item.price, &item.stock);
    item.price = item.price + 5;
    printf("%s now costs %d taka, %d in stock\n", item.name, item.price, item.stock);
    return 0;
}

lentils now costs 125 taka, 25 in stock

That output is for the input lentils 120 25.

So item.price is a box like any other int: read it, write it, or hand its address to scanf.

Assignment copies the whole record

Maria wants a weekend offer: the same rice at 60 taka, under its own name. She copies the record with one =, then changes the copy.

#include <stdio.h>
#include <string.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

int main(void)
{
    struct product rice = { "rice", 65, 40 };
    struct product offer = { 0 };

    offer = rice;
    strcpy(offer.name, "rice offer");
    offer.price = 60;

    printf("%s: %d taka, %d in stock\n", rice.name, rice.price, rice.stock);
    printf("%s: %d taka, %d in stock\n", offer.name, offer.price, offer.stock);
    return 0;
}

Each row shows both records after that line has run.

rice: 65 taka, 40 in stock
rice offer: 60 taka, 40 in stock

One = copied all three fields, the name's 20 char boxes included. From then on the records are separate: changing offer never touches rice, just as with two int variables (Module 2, lesson 1).

An array alone cannot be assigned with = (Module 11, lesson 3). Yet the array inside this struct was copied. A struct is one value, and = copies a value whole, whatever is inside.

The field alone is still an array, though. Bob renames the offer with offer.name = "rice offer";. An error on every command line, the Playground included: error: assignment to expression with array type, under the badge Compile error. Put text into a char array field with strcpy from <string.h> (Module 10, lesson 4), as Maria did.

So = copies every field of a struct at once, but a char array field alone still needs strcpy.

No == for structs: write the comparison yourself

If = copies a whole record, surely == compares two? Maria writes if (rice == offer) to check her copy. An error on every command line, the Playground included: error: invalid operands to binary == (have 'struct product' and 'struct product').

An operand is a value an operator works on, and a binary operator takes two. GCC is saying == means nothing for two values of type struct product. C leaves it out on purpose: only you know what equal means for your type. Lesson 6 adds a second reason, found in the bytes between fields.

So you write the comparison as a function. Zara checks that the shelf matches Maria's stock book, field by field. Numbers compare with ==; names compare with strcmp, which returns 0 when two strings match.

#include <stdio.h>
#include <string.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

int equal_products(struct product a, struct product b);

int main(void)
{
    struct product shelf = { "oil", 180, 12 };
    struct product book = { "oil", 180, 12 };
    struct product label = { "oil", 185, 12 };

    printf("shelf and book: %d\n", equal_products(shelf, book));
    printf("shelf and label: %d\n", equal_products(shelf, label));
    return 0;
}

int equal_products(struct product a, struct product b)
{
    return strcmp(a.name, b.name) == 0
        && a.price == b.price
        && a.stock == b.stock;
}

shelf and book: 1
shelf and label: 0

The function returns 1 when all three fields match, and 0 otherwise; the shelf label says 185 taka. If Maria later decides stock does not count, she changes one function, not every if in her program.

So C gives structs = but not ==, and "equal" means whatever your function says.

A function that takes a struct

Maria prints products in many places, and copying the same printf everywhere is how typos get in. So Alice writes it once, as a function. A struct type can be a parameter, just like int.

#include <stdio.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

void print_product(struct product p);

int main(void)
{
    struct product rice = { "rice", 65, 40 };
    struct product oil = { "oil", 180, 12 };
    struct product lentils = { "lentils", 120, 25 };

    print_product(rice);
    print_product(oil);
    print_product(lentils);
    return 0;
}

void print_product(struct product p)
{
    printf("%-8s %4d taka %4d in stock\n", p.name, p.price, p.stock);
}

rice       65 taka   40 in stock
oil       180 taka   12 in stock
lentils   120 taka   25 in stock

The prototype comes after the struct definition, because it uses the type. %-8s pads each name to 8 places and %4d gives each number 4, so the columns line up (Module 3, lesson 3).

A parameter is a fresh box holding a copy of the argument (Module 7, lesson 3). A struct is no exception: p is a new record with a copy of every field. That lesson promised copies get expensive for structures. Lesson 2 measures the cost, and lesson 3 avoids it.

So a function can take a whole record as one parameter, and it works on its own copy.

The struct in memory

A struct variable is one block of memory. C17 promises that its fields sit in the order you declared them, at increasing addresses. The first one starts where the struct starts. Kenji asks sizeof (Module 2, lesson 5), and adds a small record of his own.

#include <stdio.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

struct result {
    char grade;
    int marks;
};

int main(void)
{
    struct product rice = { "rice", 65, 40 };
    struct result kenji = { 'A', 91 };

    printf("name %zu + price %zu + stock %zu\n",
           sizeof rice.name, sizeof rice.price, sizeof rice.stock);
    printf("sizeof rice: %zu\n", sizeof rice);
    printf("grade %zu + marks %zu\n", sizeof kenji.grade, sizeof kenji.marks);
    printf("sizeof kenji: %zu\n", sizeof kenji);
    return 0;
}

name 20 + price 4 + stock 4
sizeof rice: 28
grade 1 + marks 4
sizeof kenji: 8

For rice the sizes add up: 20 + 4 + 4 = 28. A field's offset is how many bytes it sits from the start of the struct. Measured on Compiler Explorer's GCC 12 at the Playground's -O2, name is at 0, price at 20 and stock at 24.

Kenji's record does not add up: a char is 1 byte and an int is 4, yet sizeof kenji is 8. The compiler left 3 unused bytes after grade, so marks starts at offset 4. Such bytes are called padding, and lesson 6 explains them.

So the fields sit in declaration order, and a struct's sizeof is at least the sum of its fields, sometimes more.

#include <stdio.h>

struct point {
    int x;
    int y;
};

int main(void)
{
    struct point shop = { 3, 4 };

    printf("the shop is at (%d, %d)\n", shop.x, shop.y);
    shop.x = 5;
    printf("after the move: (%d, %d)\n", shop.x, shop.y);
    return 0;
}

the shop is at (3, 4)
after the move: (5, 4)

#include <stdio.h>

struct point {
    int x;
    int y;
};

void print_point(struct point p);

int main(void)
{
    struct point depot = { -40, 10 };
    struct point shop = { 120, 70 };
    struct point halfway = { 0 };

    halfway.x = (depot.x + shop.x) / 2;
    halfway.y = (depot.y + shop.y) / 2;

    printf("depot:   ");
    print_point(depot);
    printf("shop:    ");
    print_point(shop);
    printf("halfway: ");
    print_point(halfway);
    return 0;
}

void print_point(struct point p)
{
    printf("(%d, %d)\n", p.x, p.y);
}

depot:   (-40, 10)
shop:    (120, 70)
halfway: (40, 40)

#include <stdio.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

void print_product(struct product p);

int main(void)
{
    struct product item = { 0 };
    int sold = 0;

    scanf("%19s %d %d %d", item.name, &item.price, &item.stock, &sold);

    printf("before: ");
    print_product(item);
    item.stock = item.stock - sold;
    printf("after:  ");
    print_product(item);
    printf("takings: %d taka\n", sold * item.price);
    return 0;
}

void print_product(struct product p)
{
    printf("%s, %d taka, %d in stock\n", p.name, p.price, p.stock);
}

before: tea, 120 taka, 30 in stock
after:  tea, 120 taka, 26 in stock
takings: 480 taka

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
}

void print_product(struct product p);

struct product oil = { "oil", 12, 180 };

struct point shop = { 3, 4 };

printf("%d\n", shop);

#include <stdio.h>

int main(void)
{
    struct { int a; } x = { 1 }, y = { 2 };

    x = y;
    printf("x.a is %d\n", x.a);
    if (x == y) {
        printf("equal\n");
    }
    return 0;
}

#include <stdio.h>

#define NAME_LEN 20

struct product {
    char name[NAME_LEN];
    int price;
    int stock;
};

void print_product(struct product p);

int main(void)
{
    struct product item = { 0 };

    scanf("%19s %d %d", item.name, &item.price, &item.stock);
    print_product(item);
    return 0;
}

void print_product(struct product p)
{
    /* Print the three fields of p on one line, in the exact words
       of the Output section: the name, the price, then the stock. */
}

#include <stdio.h>
#include <math.h>

struct point {
    int x;
    int y;
};

double distance(struct point a, struct point b);

int main(void)
{
    struct point a = { 0 };
    struct point b = { 0 };

    while (scanf("%d %d %d %d", &a.x, &a.y, &b.x, &b.y) == 4) {
        printf("%.2f\n", distance(a, b));
    }
    return 0;
}

double distance(struct point a, struct point b)
{
    /* How far apart are the two x fields, and the two y fields?
       Pythagoras joins them: the square root of the sum of their squares. */
    return 0.0;
}

#include <stdio.h>

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

int is_valid(struct date d);

int main(void)
{
    struct date d = { 0 };

    scanf("%d %d %d", &d.day, &d.month, &d.year);
    if (is_valid(d)) {
        printf("valid\n");
    } else {
        printf("invalid\n");
    }
    return 0;
}

int is_valid(struct date d)
{
    /* First the month: is d.month between 1 and 12?
       Then the day: how many days does that month have in d.year? */
    return 0;
}

Next, Amara keeps a whole class of these records in one array, and passes them to functions.