Prologue

This article illustrates simulated classes and objects in pure C.

External Program to Call C Objects

/* main.c */
#include <stdio.h>
#include <stdlib.h>
#include "point.h"
define PUTERR(format, ...) \
fprintf(stderr, format "\n", ##__VA_ARGS__);
int main(void)
{
point_t p = NULL;
point_t q = NULL;
double d;
p = point_zero();
if (!p) {
    PUTERR(&quot;Fails to create p&quot;);
    goto ERROR_MAIN;
}

q = point_new(3.0, 4.0);
if (!q) {
    PUTERR(&quot;Fails to create q&quot;);
    goto ERROR_MAIN;
}

if (!(3.0 == point_x(q))) {
    PUTERR(&quot;Wrong value x: %.2f&quot;, point_x(q));
    goto ERROR_MAIN;
}

if (!(4.0 == point_y(q))) {
    PUTERR(&quot;Wrong value y: %.2f&quot;, point_y(q));
    goto ERROR_MAIN;
}

d = point_distance_between(p, q);
if (!(5.0 == d)) {
    PUTERR(&quot;Wrong distance: %.2f&quot;, d);
    goto ERROR_MAIN;
}

point_delete((void *) q);
point_delete((void *) p);

return 0;
ERROR_MAIN:
if (q)
point_delete((void *) q);
if (p)
    point_delete((void *) p);

return 1;
}

External Interface of a C Object

/* point.h */
#pragma once
/ An opaque struct. /
typedef struct point_t point_t;
ifdef __cplusplus
extern "C" {
endif
point_t * point_zero(void);
point_t * point_new(double x, double y);
void point_delete(void *self);
double point_x(point_t *self);
double point_y(point_t *self);
double point_distance_between(point_t *p, point_t *q);
ifdef __cplusplus
}
endif

Internal Implementation of a C Object

/* point.c */
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include "point.h"
struct point_t {
double x;
double y;
};
point_t * point_zero(void)
{
return point_new(0.0, 0.0);
}
point_t  point_new(double x, double y)
{
point_t self = \
(point_t *) malloc(sizeof(point_t));
if (!self)
return self;
point_set_x(self, x);
point_set_y(self, y);

return self;
}
void point_delete(void *self)
{
if (!self)
return;
free(self);
}
double point_x(point_t *self)
{
assert(self);
return self-&gt;x;
}
double point_y(point_t *self)
{
assert(self);
return self-&gt;y;
}
double point_distance_between(point_t p, point_t q)
{
assert(p && q);
double dx = point_x(p) - point_x(q);
double dy = point_y(p) - point_y(q);

return sqrt(dx * dx + dy * dy);
}

README

C lacks built-in supports to object-oriented programming. Therefore, we simulate classes and objects with C struct.