2.2.1 Replace namespaces with name prefixes

In C++, namespaces help different libraries not collide. In C, the tradition is to prefix every function and global variable name with the same prefix, like glViewport instead of just viewport in OpenGL or sqlite3_open instead of open in SQLite.

We use the prefix dll in our provided header file.

2.2.2 Replace overloads and templates with name suffixes

In C++, foo(int) and foo(double) can co-exist; in C they cannot. The traditional solution is to add a type-specific suffix to the function name, like sqrt(double) and sqrtf(float). If there’s just a single parameter, suffixes based on printf percent codes are common; for anything more complicated there’s no single pattern.

Templated functions can be removed in a similar type-suffix way, but if there’s more than a few types expected it is more common to replace the templated-type argument with something like a type code and a void *; for example, something like

size_t sizeOfThing(char type, void *value) {
  if (type == 'i') {
    int val = (int)value;
    return val < 0 ? -val : val;
  }
  if (type == 's') {
    char *str = (char *)value;
    return strlen(str);
  }
  // ...
}

We used the suffix c for what in C++ was a <char> template, and s for what was a <std::string> template.

2.2.3 Explicit this

C has no built-in object orientation. As long as you are not using inheritance, this is a relatively small obstacle; just add the this-argument as the explicit first argument of each method and add a namespace-like renaming.

class Pt2D {
  double x,y;
  Pt2D(double x, double y) { this.x = x; this.y = y; }
  void move(double x, double y) { this.x += x; this.y += y; }
  double theta() { return atan2(y, x); }
  double r() { return hypot(x,y); }
};

typedef struct {
  double x,y;
} Pt2D;
void pt2d_init(Pt2D *self, double x, double y);
void pt2d_move(Pt2D *self, double x, double y);
double pt2d_theta(Pt2D *self);
double pt2d_r(Pt2D *self);

#include "the h file you created.h"

void pt2d_init(Pt2D *self, double x, double y) { self->x = x; self->y = y; }
void pt2d_move(Pt2D *self, double x, double y) { self->x += x; self->y += y; }
double pt2d_theta(Pt2D *self) { return atan2(self->y, self->x); }
double pt2d_r(Pt2D *self) { return hypot(self->y, self->x); }

Pt2D *pt2d_new(double x, double y) {
  Pt2D *self = malloc(sizeof(Pt2D);
  self->x = x; self->y = y;
  return self;
}
void pt2d_delete(Pt2D *self) { free(self); }

2.2.4 Language tweaks

Replace new with malloc + initialization.

Replace delete with free (preceded by deinitialization if there’s a destructor).

Replace std::string with char *.

Replace operator overloading with explicit function calls: strcat instead of std::string’s + operator, printf instead of cout’s << operator, and so on.

There are no auto declarations, iterator loops, or lambda expressions in C.

Replace pass-by-reference code with pass-by-pointer, adding needed */-> operators to make that work.

To match prevailing style, move where *s appear in type declarations. In C it is tradition to write int *x, not int* x like in C++. It is also traditional to declare multiple pointers per line, like int *x, *y.