typestar

vector.c en C

Un arreglo que crece como módulo hecho y derecho: create, push, get, destroy.

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

typedef struct {
    int *items;
    size_t len;
    size_t cap;
} Vector;

static int vector_init(Vector *v, size_t cap) {
    v->items = cap ? malloc(cap * sizeof(int)) : NULL;
    v->len = 0;
    v->cap = (cap && v->items == NULL) ? 0 : cap;
    return !(cap && v->items == NULL);
}

static int vector_push(Vector *v, int value) {
    if (v->len == v->cap) {
        size_t bigger = v->cap ? v->cap * 2 : 4;
        int *grown = realloc(v->items, bigger * sizeof(int));
        if (grown == NULL) {
            return 0;
        }
        v->items = grown;
        v->cap = bigger;
    }
    v->items[v->len++] = value;
    return 1;
}

static int vector_get(const Vector *v, size_t i, int *out) {
    if (i >= v->len) {
        return 0;
    }
    *out = v->items[i];
    return 1;
}

static void vector_free(Vector *v) {
    free(v->items);
    v->items = NULL;
    v->len = 0;
    v->cap = 0;
}

int main(void) {
    Vector v;
    if (!vector_init(&v, 2)) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    for (int i = 1; i <= 10; i++) {
        if (!vector_push(&v, i * i)) {
            fprintf(stderr, "push failed at %d\n", i);
            vector_free(&v);
            return 1;
        }
    }

    printf("len %zu cap %zu\n", v.len, v.cap);

    int value = 0;
    for (size_t i = 0; i < v.len; i += 3) {
        if (vector_get(&v, i, &value)) {
            printf("[%zu] = %d\n", i, value);
        }
    }
    printf("out of range read: %d\n", vector_get(&v, 99, &value));

    vector_free(&v);
    return 0;
}

Cómo funciona

  1. El struct es opaco para quien llama; todo pasa por sus funciones.
  2. Cada ruta de falla deja el vector válido y lo reporta.
  3. main ejercita el crecimiento más allá de la capacidad inicial.

Palabras clave y builtins usados aquí

El intento, en números

Líneas
73
Caracteres a escribir
1301
Tokens
478
Ritmo de tres estrellas
105 tpm

Al ritmo de tres estrellas de 105 tokens por minuto, este intento toma unos 273 segundos.

Escribe este fragmento

Paso 2 de 2 en Bis; paso 25 de 25 en Punteros y memoria.

← Anterior