Post History

Why is private encapsulation "good" in (C) programming?

I have read several times that it is implied that it is "good" programming style to have private encapsulation. But I'm curious to know what exactly makes it good.

For example, the code below does not use private encapsulation because the user of the ring-buffer (main.c) has access to all the ring-buffer's members. When we think about it, the user should really only be able to put and get items.

```C
/* ring_buffer.h */
#define RINGBUFFER_SZ 32
typedef struct 
{
    uint8_t buf[RING_BUFFER_SZ];
    volatile size_t head;
    volatile size_t tail;
} ringbuffer_t;

void rb_init(ringbuffer_t* rb);
void rb_put(ringbuffer_t* rb, uint8_t item);
uint8_t rb_get(ringbuffer_t* rb);
```

```C
/* main.c */
#include "ring_buffer.h"
static ringbuffer_t rb;

int main(void)
{
    rb_init(&rb);
    rb.head = 0u; //User can do this if he wanted to - for some reason 
}
```

If the user of the ring-buffer wanted to, he could set all the members to arbitrary values. I see why this is bad but why would we ever expect the user to want to do that? Private encapsulation via forward declaring the ring-buffer struct and defining the struct in `ring_buffer.c`, or by simply defining the ring-buffer struct statically in `ring_buffer.c` as a variable at file scope would prevent this problem.

I'm seeking a clear explanation of why private encapsulation is good programming style in general.