Input, Output and Files

#include <stdio.h>

int main(void)
{
    fprintf(stdout, "normal output\n");
    fprintf(stderr, "diagnostics go here\n");       // never mix these two purposes

    // printf(...) is exactly fprintf(stdout, ...)
    printf("%s\n", "the same stream");
    return 0;
}

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

int main(void)
{
    // Whole strings out: puts adds a newline, fputs does not.
    puts("puts adds a newline");
    fputs("fputs does not\n", stdout);

    // Characters out.
    putchar('x');
    putc('\n', stdout);

    // Characters in: the return type is int, so EOF (-1) is distinguishable
    // from every valid character value. NEVER use a char here.
    int c = getchar();
    if (c != EOF) {
        printf("first character: %c\n", c);
        ungetc(c, stdin);                   // push one character back
    }

    // Lines in: fgets keeps the newline and always NUL-terminates.
    char line[256];
    while (fgets(line, sizeof line, stdin) != nullptr) {
        size_t len = strlen(line);

        if (len > 0 && line[len - 1] == '\n') {
            line[len - 1] = '\0';           // strip the newline
        } else if (len == sizeof line - 1) {
            // No newline and the buffer is full: the line was longer than the buffer.
            int discarded;
            while ((discarded = getchar()) != '\n' && discarded != EOF) {
                /* drain the rest of the line */
            }
        }

        printf("[%s]\n", line);
    }
    return 0;
}

#include <inttypes.h>
#include <stdio.h>

int main(void)
{
    char buffer[64];

    printf("to stdout\n");
    fprintf(stderr, "to a stream\n");

    // snprintf: writes at most n bytes INCLUDING the NUL, always terminates,
    // and returns the length it WANTED -- so >= n means truncation.
    int needed = snprintf(buffer, sizeof buffer, "%s-%d", "id", 42);
    if (needed < 0 || (size_t)needed >= sizeof buffer) {
        fputs("truncated\n", stderr);
    }
    printf("%s (needed %d)\n", buffer, needed);

    // Measure first, then allocate: snprintf(nullptr, 0, ...) just computes the length.
    int length = snprintf(nullptr, 0, "%s-%d", "id", 42);
    printf("exact length is %d\n", length);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0, b = 0;

    // ALWAYS check the return value: it is the number of items ASSIGNED,
    // which may be fewer than requested, or EOF.
    int assigned = sscanf("10 20", "%d %d", &a, &b);
    if (assigned != 2) {
        fputs("parse failed\n", stderr);
    }
    printf("%d %d (assigned %d)\n", a, b, assigned);

    // %s with no width is a buffer overflow waiting to happen. Bound it:
    char word[16];
    if (sscanf("overlongwordthatwouldoverflow", "%15s", word) == 1) {
        printf("[%s]\n", word);
    }

    // %[...] scan sets, and %*d to parse-and-discard a field:
    char key[32], value[32];
    if (sscanf("name=alice", "%31[^=]=%31s", key, value) == 2) {
        printf("%s -> %s\n", key, value);
    }
    return 0;
}

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

// Returns true and writes *out on success; false on any malformed input.
static bool parse_int(const char *text, long *out)
{
    errno = 0;
    char *end = nullptr;
    long value = strtol(text, &end, 10);

    if (end == text) {
        return false;                       // no digits at all
    }
    while (*end == ' ' || *end == '\n' || *end == '\t') {
        ++end;                              // allow trailing whitespace
    }
    if (*end != '\0') {
        return false;                       // trailing garbage
    }
    if (errno == ERANGE) {
        return false;                       // out of range
    }

    *out = value;
    return true;
}

int main(void)
{
    const char *inputs[] = { "42", "  -7 \n", "12abc", "", "99999999999999999999" };

    for (size_t i = 0; i < sizeof inputs / sizeof inputs[0]; ++i) {
        long value = 0;
        printf("%-24s -> %s", inputs[i],
               parse_int(inputs[i], &value) ? "ok" : "rejected");
        if (parse_int(inputs[i], &value)) {
            printf(" (%ld)", value);
        }
        putchar('\n');
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    FILE *f = fopen("/tmp/c-demo-output.txt", "w");
    if (f == nullptr) {
        perror("fopen");                    // ALWAYS check, and report why
        return EXIT_FAILURE;
    }

    fprintf(f, "line one\nline two\n");

    // fclose flushes; it can FAIL (a full disk shows up here, not at fprintf).
    if (fclose(f) != 0) {
        perror("fclose");
        return EXIT_FAILURE;
    }

    f = fopen("/tmp/c-demo-output.txt", "r");
    if (f == nullptr) {
        perror("fopen");
        return EXIT_FAILURE;
    }

    char line[128];
    while (fgets(line, sizeof line, f) != nullptr) {
        fputs(line, stdout);
    }

    if (ferror(f)) {                        // distinguish a read error from EOF
        fputs("read error\n", stderr);
    }
    fclose(f);
    remove("/tmp/c-demo-output.txt");
    return 0;
}

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const char *path = "/tmp/c-demo-binary.dat";
    uint32_t written[4] = { 1, 2, 3, 4 };

    FILE *out = fopen(path, "wb");           // note the b
    if (out == nullptr) {
        perror("fopen");
        return EXIT_FAILURE;
    }

    // fwrite returns the number of ELEMENTS written, not bytes.
    size_t count = fwrite(written, sizeof written[0], 4, out);
    if (count != 4) {
        fputs("short write\n", stderr);
        fclose(out);
        return EXIT_FAILURE;
    }
    fclose(out);

    FILE *in = fopen(path, "rb");
    if (in == nullptr) {
        perror("fopen");
        return EXIT_FAILURE;
    }

    uint32_t read_back[4] = { 0 };
    size_t got = fread(read_back, sizeof read_back[0], 4, in);

    if (got != 4) {
        // A short read is either EOF or an error -- check which.
        if (feof(in)) {
            fputs("unexpected end of file\n", stderr);
        } else if (ferror(in)) {
            fputs("read error\n", stderr);
        }
    }
    fclose(in);
    remove(path);

    printf("%zu elements: %u %u %u %u\n", got,
           read_back[0], read_back[1], read_back[2], read_back[3]);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    const char *path = "/tmp/c-demo-seek.txt";

    FILE *f = fopen(path, "w+b");
    if (f == nullptr) {
        perror("fopen");
        return EXIT_FAILURE;
    }
    fputs("ABCDEFGHIJ", f);

    // fseek: SEEK_SET (from the start), SEEK_CUR, SEEK_END.
    if (fseek(f, 4, SEEK_SET) != 0) {
        perror("fseek");
        fclose(f);
        return EXIT_FAILURE;
    }
    printf("byte at offset 4: %c\n", (char)fgetc(f));       // E

    long position = ftell(f);                               // -1L on failure
    printf("position now %ld\n", position);

    // fgetpos/fsetpos handle offsets too large for a long, and are the portable
    // choice for large files.
    fpos_t saved;
    if (fgetpos(f, &saved) == 0) {
        fseek(f, 0, SEEK_END);
        printf("size = %ld\n", ftell(f));
        fsetpos(f, &saved);                                 // back where we were
    }

    rewind(f);                                              // offset 0, clears error flags
    printf("first byte: %c\n", (char)fgetc(f));             // A

    fclose(f);
    remove(path);
    return 0;
}

#include <stdio.h>

int main(void)
{
    // setvbuf must be called before any I/O on the stream.
    static char my_buffer[BUFSIZ];
    if (setvbuf(stdout, my_buffer, _IOFBF, sizeof my_buffer) != 0) {
        fputs("setvbuf failed\n", stderr);
    }

    printf("this may sit in the buffer");
    fflush(stdout);                     // force it out now
    putchar('\n');

    // _IONBF (unbuffered), _IOLBF (line-buffered), _IOFBF (fully buffered)
    setvbuf(stderr, nullptr, _IONBF, 0);

    // fflush(nullptr) flushes every output stream.
    fflush(nullptr);
    return 0;
}

#include <stdio.h>

int main(void)
{
    FILE *f = stdin;
    int c;

    // WRONG -- processes the final item twice, because feof is only set after
    // a read has already hit the end:
    //   while (!feof(f)) { c = fgetc(f); putchar(c); }

    // RIGHT -- test the read itself, then ask WHY it stopped:
    while ((c = fgetc(f)) != EOF) {
        putchar(c);
    }

    if (ferror(f)) {
        fputs("read error\n", stderr);
        clearerr(f);                    // reset both flags
        return 1;
    }
    if (feof(f)) {
        fputs("clean end of input\n", stderr);
    }
    return 0;
}