Buffer Array Usage in C - c

Question

My mind tells me there is something wrong here, like maybe I won't be able to append a value to the last element in the array, or it will exceed the UINT8 when doing the cbuf_length++ and crash? My mind thinks something is wrong, but i just can't see what it is. What is the best way to use arrays that will allow me to append to all 256 elements in the array without crashing or confusing the next programmer?
#define CBUF_SIZE 256
static UINT8 cbuf[CBUF_SIZE];
static UINT8 cbuf_length;
void CBUF_AppendChar(char c)
{
if (cbuf_length < CBUF_SIZE) {
cbuf[cbuf_length] = c;
cbuf_length++;
}
}

Answer 1

First, there's some issues with your code.
UINT8 is not a standard type, I suspect it's a Microsoft type. Unless you have a good reason, use uint8_t from stdint.h.
Second, cbuf_length < CBUF_SIZE is always true because uint8_t can't store higher than 255.
test.c:10:21: warning: comparison of constant 256 with expression of type 'uint8_t'
(aka 'unsigned char') is always true [-Wtautological-constant-out-of-range-compare]
if (cbuf_length < CBUF_SIZE) {
~~~~~~~~~~~ ^ ~~~~~~~~~
More important, global variables and constants should be avoided. They create complexity, limit you to a single instance, cause problems with concurrency. It's not always clear which global variables must be updated together. It's also not immediately clear what functions affect what data.
Instead, consider using a struct.
For array sizes use size_t to avoid exactly the sort of bug you have where the size of the array is larger than the capacity of your type. size_t is the type for storing, you guessed it, sizes! It will always be large enough.
Finally, don't forget error handling. Like when your buffer can hold no more elements. In this case I have the append function return a boolean which can be checked to see if the append succeeded. (I've been sloppy in a few other places, like not checking malloc).
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
typedef struct {
uint8_t *buf;
size_t size;
size_t capacity;
} cbuf;
cbuf *cbuf_new( size_t capacity ) {
cbuf *self = malloc( sizeof(cbuf) );
self->size = 0;
self->capacity = capacity;
self->buf = malloc( capacity * sizeof(uint8_t) );
return self;
}
bool cbuf_append( cbuf *self, char c) {
// Get the error check out of the way early.
if( self->size >= self->capacity ) {
return false;
}
// Don't forget to cast signed char to uint8_t.
self->buf[self->size] = (uint8_t)c;
self->size++;
return true;
}
int main(void) {
cbuf *buf = cbuf_new(2);
cbuf_append(buf, 'f'); // true
cbuf_append(buf, 'o'); // true
cbuf_append(buf, 'o'); // false
// Prints 'fo'
for( size_t i = 0; i < buf->size; i++ ) {
printf("%c", buf->buf[i]);
}
puts("");
}
All the information about the buffer is collected together in a single struct. Now it's immediately clear that cbuf_append works on buf. You can have multiple buffers if you wish.
If you really want a statically allocated buffer, a slight modification gives you optional control of the memory allocation.
cbuf *cbuf_new_from_buf( uint8_t *buf, size_t capacity ) {
cbuf *self = malloc( sizeof(cbuf) );
self->size = 0;
self->capacity = capacity;
self->buf = buf;
bzero( self->buf, self->capacity );
return self;
}
cbuf *cbuf_new( size_t capacity ) {
return cbuf_new_from_buf(
malloc( capacity * sizeof(uint8_t) ),
capacity
);
}
Now you can still use cbuf_new() to let it take care of memory allocation for you. Or you can use cbuf_new_from_buf() to use an existing buffer you've already allocated.
uint8_t mybuf[2];
cbuf *buf = cbuf_new_from_buf(mybuf, sizeof(mybuf));
But you shouldn't be writing your own buffers!
This is all fine for a learning exercise. But in production if all you want is a sized array you can append to, don't write a bunch of code that you'll (or somebody else) will have to document and maintain and test and fix and add features to. Use an existing library. Like GLib's GArray type. It does what you want and more.
#include <glib.h>
#include <stdio.h>
#include <stdint.h>
int main(void) {
// Start with a size 2 buffer, it will grow as needed.
GArray *buf = g_array_sized_new(FALSE, FALSE, sizeof(uint8_t), 2);
uint8_t c = 'f';
g_array_append_val(buf, c);
c = 'o';
g_array_append_val(buf, c);
c = 'o';
g_array_append_val(buf, c); // It will grow the buffer.
for( guint i = 0; i < buf->len; i++ ) {
printf("%c", g_array_index(buf, uint8_t, i));
}
puts("");
}
While GArray has some quirks, like not being able to append literals, it's well documented, powerful, and fast. That means you can spend your time on the real code, not basic data structures.
Even better, because the array will grow if necessary there's no chance of a buffer overflow and no need to check if the append succeeded. Your original concern about the buffer size is eliminated, the buffer will just grow as necessary.

Answer 2

The only mistake is in the type of cbuf_length — after 255, it will overflow to 0. Defining it as a larger type (UINT16 or even just unsigned) will fix it.
Other than that, it's perfectly valid and understandable code. You might want to return something from that function, though — some boolean result telling the caller whether the value was appended successfully or not.