C23 Vector Macro Implementation

Question

I'm trying to implement a simple type-generic Vector with macros using the newest features of C23. Looking for any advice about macro design and pitfalls because I generally avoid macros at all costs. Wondering how to extend this code to handle more complex data types as well.

Also, I'm not particularly happy with the hacky int vector_abort() used in the vector_at() ternary. Any portable advice here is greatly appreciated. Furthermore, if anyone has a way to make opaque structures with macros I would be very interested.

A major problem that I immediately notice is that there isn't an easy way to tell if vector_push() was successful. However, return values aren't permitted for macros and calling abort() or exit() doesn't seem great in this instance.

C23 features used:

• nullptr constant from <stddef.h>
• true and false keywords
• free_sized() from <stdlib.h>
• = {} empty initializer
• function() empty function argument declaration
• typeof operator
• N3003 Improved Rules for Tag Compatibility

vector.h

#ifndef VECTOR_H #define VECTOR_H #include <errno.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> int vector_abort(void) { errno = EINVAL; fprintf(stderr, "ERROR: %s.\n" "Invalid vector index.\n", strerror(errno)); errno = 0; abort(); return 0; } #define vector(TYPE) struct vector_##TYPE {size_t length; size_t capacity; TYPE* array;} #define vector_new(TYPE, CAPACITY) {.length = 0, .capacity = CAPACITY, .array = calloc(CAPACITY, sizeof(TYPE))} #define vector_delete(VECTOR) \ do { \ VECTOR.length = 0; \ VECTOR.capacity = 0; \ free_sized(VECTOR.array, (VECTOR.length * sizeof(*(VECTOR.array)))); \ VECTOR.array = nullptr; \ } while (false) #define vector_size(VECTOR) VECTOR.length #define vector_at(VECTOR, INDEX) (VECTOR.length > INDEX) ? VECTOR.array[INDEX] : vector_abort() #define vector_pop(VECTOR) if (VECTOR.length > 0) VECTOR.length-- #define vector_push(VECTOR, VALUE) \ do { \ if (VECTOR.length == VECTOR.capacity) { \ typeof(VECTOR.array) new_array = realloc(VECTOR.array, (VECTOR.capacity * 2 * sizeof(*(VECTOR.array)))); \ if (!new_array) break; \ VECTOR.capacity *= 2; \ VECTOR.array = new_array; \ } \ VECTOR.array[VECTOR.length] = VALUE; \ VECTOR.length++; \ } while (false) #endif 

main.c

#include "./vector.h" #include <stdio.h> int main(void) { vector(int) v = {}; // or use = vector_new(type, capacity) vector_push(v, 1); vector_push(v, 2); vector_push(v, 3); for (size_t i = 0; i < vector_size(v); ++i) { printf("Test Push %d\n", vector_at(v, i)); } vector_pop(v); for (size_t i = 0; i < vector_size(v); ++i) { printf("Test Pop %d\n", vector_at(v, i)); } vector_delete(v); for (size_t i = 0; i < vector_size(v); ++i) { printf("Test Delete %d\n", vector_at(v, i)); } return EXIT_SUCCESS; } 

Polyfill

Here is a free_sized() polyfill if your implementation doesn't support it yet.

void free_sized(void* ptr, size_t /*size*/) { free(ptr); } 

Compiler Flags

-Wall-Wextra-Werror-pedantic-errors-std=c2x

Answer 1

Improve macro safety

You seem to have hit the usual pitfalls of macros - remember these are text substitutions done by the C preprocessor, so we need to ensure that the the rules of precedence don't give an unexpected meaning to the expansion.

For example, consider vector_pop:

#define vector_pop(VECTOR) if (VECTOR.length > 0) VECTOR.length-- 

Since . binds very tightly and if can catch a following else, we really need extra parens and a do/while (0):

#define vector_pop(VECTOR) \ do { if ((VECTOR).length > 0) (VECTOR).length--; } while (false) 

Similarly, vector_size should be defined to expand to ((VECTOR).length) rather than to the much less safe VECTOR.length.

---

Improve the "abort" function

Shouldn't vector_abort() be static? At present, it seems that we'll get a definition in each translation unit that includes the header, causing link-time errors.

This function has an unreachable return statement. The assignment of errno = 0 doesn't have any discernable value - unless you have a signal handler that uses it, which seems a poor choice.

I'd write:

static _Noreturn void vector_abort(void) { fprintf(stderr, "ERROR: %s.\nInvalid vector index.\n", strerror(EINVAL)); abort(); } 

---

Handle allocation failures correctly

vector_push provides no feedback when realloc() fails - the calling program is required to test the vector size before and after (this checking is conspicuously absent from the demo program, suggesting others will forget this too).

vector_new violates the invariant (that array[capacity-1] is valid) whenever calloc() fails.