Types and Data

C does no bounds checking. Reading scores[5] compiles and may even appear to work, but it is undefined behavior. Also, when you pass an array to a function it decays into a pointer to its first element, so sizeof inside the function no longer gives you the element count. The convention is to pass the length alongside the array.

Strings are char arrays

There is no dedicated string type. A string is a char array terminated by a null character, '\0'. The literal "hi" takes three bytes: h, i, and the terminator.

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

int main(void) {
    char name[16] = "Kim";          /* a writable array */
    const char *lang = "C";         /* a string literal: never modify it */

    printf("%zu\n", strlen(name));  /* 3: the terminator is not counted */
    printf("%zu\n", sizeof name);   /* 16: the whole array */

    char buf[32];
    snprintf(buf, sizeof buf, "%s loves %s", name, lang);  /* never writes past buf */
    puts(buf);

    if (strcmp(name, "Kim") == 0) { /* compare contents with strcmp, not == */
        puts("same string");
    }
    return 0;
}

strcpy and strcat never check the destination size, which makes overflows easy. Reaching for snprintf, which takes the buffer size, is a safer habit. Comparing strings with == compares addresses rather than contents, so use strcmp.

Structs, unions, enums, and typedef

A struct groups values of different types. Access members with ., or with -> through a pointer. C99 designated initializers (.x = 1) let you initialize members by name, in any order.

An enum defines a set of named integer constants. A union overlays all its members on the same storage, so it holds only one of them at a time; it is normally paired with a tag that records which member is active. typedef gives a type a new name.

#include <stdio.h>

typedef enum { SHAPE_CIRCLE, SHAPE_RECT } ShapeKind;

typedef struct {
    double x, y;
} Point;

typedef struct {
    ShapeKind kind;            /* tag: which union member is valid */
    Point origin;
    union {
        double radius;                  /* SHAPE_CIRCLE */
        struct { double w, h; } size;   /* SHAPE_RECT */
    } u;
} Shape;

double area(const Shape *s) {
    switch (s->kind) {
    case SHAPE_CIRCLE: return 3.14159265 * s->u.radius * s->u.radius;
    case SHAPE_RECT:   return s->u.size.w * s->u.size.h;
    }
    return 0.0;
}

int main(void) {
    Shape c = { .kind = SHAPE_CIRCLE, .origin = { .x = 0, .y = 0 }, .u.radius = 2.0 };
    Shape r = { .kind = SHAPE_RECT, .u.size = { .w = 3.0, .h = 4.0 } };
    printf("%.2f %.2f\n", area(&c), area(&r));
    printf("sizeof(Shape) = %zu\n", sizeof(Shape));
    return 0;
}

Passing a struct by value copies the whole thing, so pass large structs by pointer and add const when the function only reads. A struct can be larger than the sum of its members because the compiler inserts padding for alignment.

Summary

• Integer sizes vary by platform; use <stdint.h> for exact widths and size_t for sizes and indexes.
• Signed overflow is undefined behavior; unsigned arithmetic wraps.
• Arrays have no bounds checks and decay to pointers when passed, so pass the length too.
• Strings are '\0'-terminated char arrays; handle them with snprintf and strcmp.
• Group data with structs, use tagged unions, name constants with enum, and shorten type names with typedef.