C++ Lecture 1

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

struct growing_buffer {
    char *buf;
    int n_used;
    int size;
};

int
buffer_init(struct growing_buffer *gb)
{
    gb->size = 16;
    gb->n_used = 0;
    gb->buf = (char *) malloc(gb->size);
    if (!gb->buf)
        return 0;
    return 1;
}

int
buffer_addc(struct growing_buffer *gb, char c)
{
    if (!gb->buf)     /* previous failure */
        return 0;
    if (gb->n_used >= gb->size) {
        gb->size *= 2;
        gb->buf = (char *) realloc(gb->buf, gb->size);
        if (!gb->buf) {
            gb->n_used = 0;
            gb->size = 0;
            return 0;
        }
    }
    gb->buf[gb->n_used++] = c;
    return 1;
}

void
buffer_reset(struct growing_buffer *gb)
{
    gb->n_used = 0;
}

void
buffer_release(struct growing_buffer *gb)
{
    free(gb->buf);
}

int
readline(FILE *fp, struct growing_buffer *gb)
{
    int c;

    buffer_reset(gb);
    while ((c = fgetc(fp)) != EOF) {
        if (!buffer_addc(gb, c))
            return -1;
        if (c == '\n')
            break;
    }
    if (!buffer_addc(gb, '\0'))
        return -1;
    return gb->n_used - 1;
}

int
main(int argc, char **argv)
{
    int i;
    int lineno;
    int ecode = 0;
    FILE *fp;
    struct growing_buffer gbuf;

    if (!buffer_init(&gbuf)) {
        fprintf(stderr, "can't initialize buffer\n");
        return 1;
    }
    for (i = 1; i < argc; i++) {
        fp = fopen(argv[i], "r");
        if (!fp) {
            fprintf(stderr, "can't open %s - %s\n",
                argv[i], strerror(errno));
            ecode = 1;
            continue;
        }
        lineno = 1;
        while (readline(fp, &gbuf) > 0) {
            printf("%d %s", lineno, gbuf.buf);
            lineno++;
        }
        fclose(fp);
    }
    buffer_release(&gbuf);
    return ecode;
}

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

struct growing_buffer {
    char *buf;
    int n_used;
    int size;

    int init();
    int addc(char c);
    void reset();
    void release();
};

int
growing_buffer::init()
{
    size = 16;
    n_used = 0;
    buf = (char *) malloc(size);
    if (!buf)
        return 0;
    return 1;
}

int
growing_buffer::addc(char c)
{
    if (!buf)    /* previous failure */
        return 0;
    if (n_used >= size) {
        size *= 2;
        buf = (char *) realloc(buf, size);
        if (!buf) {
            n_used = 0;
            size = 0;
            return 0;
        }
    }
    buf[n_used++] = c;
    return 1;
}

void
growing_buffer::reset()
{
    n_used = 0;
}

void
growing_buffer::release()
{
    free(buf);
}

int
readline(FILE *fp, struct growing_buffer *gb)
{
    int c;

    gb->reset();
    while ((c = fgetc(fp)) != EOF) {
        if (!gb->addc(c))
            return -1;
        if (c == '\n')
            break;
    }
    if (!gb->addc('\0'))
        return -1;
    return gb->n_used - 1;
}

int
main(int argc, char **argv)
{
    int i;
    int lineno;
    int ecode = 0;
    FILE *fp;
    struct growing_buffer gbuf;

    if (!gbuf.init()) {
        fprintf(stderr, "can't initialize buffer\n");
        return 1;
    }
    for (i = 1; i < argc; i++) {
        fp = fopen(argv[i], "r");
        if (!fp) {
            fprintf(stderr, "can't open %s - %s\n",
                argv[i], strerror(errno));
            ecode = 1;
            continue;
        }
        lineno = 1;
        while (readline(fp, &gbuf) > 0) {
            printf("%d %s", lineno, gbuf.buf);
            lineno++;
        }
        fclose(fp);
    }
    gbuf.release();

    return ecode;
}

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

class Growing_buffer {
    char *buf;
    int n_used;
    int size;

public:
    // Constructor
    Growing_buffer();
    void addc(char c);
    void reset();
    int getlen() { return n_used; }
    char * getbuf() { return buf; }
    // Destructor
    ~Growing_buffer();
};

Growing_buffer::Growing_buffer()
{
    size = 16;
    n_used = 0;
    buf = new char[size];
}

void
Growing_buffer::addc(char c)
{
    if (n_used >= size) {
        char *nbuf;

        size *= 2;
        nbuf = new char[size];
        memcpy(nbuf, buf, size / 2);
        delete [] buf;
        buf = nbuf;
    }
    buf[n_used++] = c;
}

void
Growing_buffer::reset()
{
    n_used = 0;
}

Growing_buffer::~Growing_buffer()
{
    delete [] buf;
}

int
readline(FILE *fp, Growing_buffer *gb)
{
    int c;

    gb->reset();
    while ((c = fgetc(fp)) != EOF) {
        if (!gb->addc(c))
            return -1;
        if (c == '\n')
            break;
    }
    if (!gb->addc('\0'))
        return -1;
    return gb->getlen() - 1;
}

int
main(int argc, char **argv)
{
    int i;
    int lineno;
    int ecode = 0;
    FILE *fp;
    Growing_buffer gbuf;

    for (i = 1; i < argc; i++) {
        fp = fopen(argv[i], "r");
        if (!fp) {
            fprintf(stderr, "can't open %s - %s\n",
                argv[i], strerror(errno));
            ecode = 1;
            continue;
        }
        lineno = 1;
        while (readline(fp, &gbuf) > 0) {
            printf("%d %s", lineno, gbuf.getbuf());
            lineno++;
        }
        fclose(fp);
    }
    return ecode;
}