Initial commit

Author: Christian Howe

.gitignore

@@ -0,0 +1 @@
+test

Makefile

@@ -0,0 +1,8 @@
+build:
+	gcc main.c animal.c dog.c -o test
+
+memcheck:
+	valgrind ./test
+
+clean:
+	rm test

README.md

@@ -0,0 +1,33 @@
+# Object Oriented Test
+
+Since there are so many ways to make object oriented C code, I decided to try
+out a few different methods and develop my favorite one. This is the result of
+that experiment. It's a simple example with a few classes and a simple class
+structure, with a parent Animal class and a child Dog class. The Animal class
+has a virtual method that the Dog class overwrites. It's a pretty simple method
+to do some really cool things, IMO. Other ways seemed to involve a lot more
+boilerplate code and didn't really look as pretty as I would have liked.
+
+## Build it
+
+```
+make
+```
+
+## Try it
+
+```
+./test
+```
+
+## Clean it
+
+```
+make clean
+```
+
+## Check it for memory leaks (requires valgrind)
+
+```
+make memcheck
+```

animal.c

@@ -0,0 +1,29 @@
+#include "animal.h"
+
+int animal_new(animal_t* self, const char* type) {
+  if (type == NULL) {
+    return ERROR_VAL;
+  }
+
+  self->type = malloc(strlen(type)+1);
+  strcpy(self->type, type);
+
+  return SUCCESS_VAL;
+}
+
+int animal_delete(animal_t* self) {
+  if (self->type != NULL) {
+    free(self->type);
+    self->type = NULL;
+  }
+
+  return SUCCESS_VAL;
+}
+
+void animal_speak(animal_t* self) {
+  if (self->vtable.speak) {
+    return self->vtable.speak(self);
+  }
+
+  printf("This %s cannot speak!", self->type);
+}

animal.h

@@ -0,0 +1,36 @@
+#ifndef ANIMAL_H
+#define ANIMAL_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "error.h"
+
+typedef struct {
+  struct {
+    void (*speak)(void* self);
+  } vtable;
+
+  char* type;
+} animal_t;
+
+int animal_new(animal_t* self, const char* type);
+
+int animal_delete(animal_t* self);
+
+void animal_speak(animal_t* self);
+
+// Create a nice structure to expose them in :D
+static const struct {
+  int (*new)(animal_t*, const char*);
+  int (*delete)(animal_t*);
+
+  void (*speak)(animal_t*);
+} Animal = {
+  .new = &animal_new,
+  .delete = &animal_delete,
+  .speak = &animal_speak,
+};
+
+#endif // ANIMAL_H

dog.c

@@ -0,0 +1,47 @@
+#include "dog.h"
+
+void dog_speak (void* _self) {
+  dog_t* self = _self;
+  printf("'woof!' says the %s %s dog!\n", self->size, self->furColor);
+}
+
+int dog_new (dog_t* self, const char* furColor, const char* size) {
+  if (furColor == NULL || size == NULL) {
+    return ERROR_VAL;
+  }
+
+  Animal.new(&(self->super), "dog");
+
+  self->super.vtable.speak = &dog_speak;
+
+  self->furColor = malloc(strlen(furColor) + 1);
+  strcpy(self->furColor, furColor);
+
+  self->size = malloc(strlen(size) + 1);
+  strcpy(self->size, size);
+
+  return SUCCESS_VAL;
+}
+
+int dog_delete (dog_t* self) {
+  Animal.delete(&self->super);
+
+  if (self->furColor != NULL) {
+    free(self->furColor);
+    self->furColor = NULL;
+  }
+  if (self->size != NULL) {
+    free(self->size);
+    self->size = NULL;
+  }
+
+  return SUCCESS_VAL;
+}
+
+const char* dog_getFurColor (dog_t* self) {
+  return self->furColor;
+}
+
+const char* dog_getSize (dog_t* self) {
+  return self->size;
+}

dog.h

@@ -0,0 +1,47 @@
+#ifndef DOG_H
+#define DOG_H
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "error.h"
+
+// INHERITS FROM ANIMAL
+#include "animal.h"
+
+typedef struct {
+  animal_t super;
+  char* furColor;
+  char* size;
+} dog_t;
+
+// Creates a dog, takes fur color and size. Returns pointer to dog. This copies
+// the strings.
+int dog_new (dog_t* self, const char* furColor, const char* size);
+
+// Deletes a dog. Takes pointer to dog created with dog_ctor D:
+int dog_delete (dog_t* self);
+
+// Gets the fur color passed to the constructor, takes pointer to dog created
+// with dog_ctor.
+const char* dog_getFurColor (dog_t* self);
+
+// Gets the size passed to the constructor, takes pointer to dog created with
+// dog_ctor.
+const char* dog_getSize (dog_t* self);
+
+// Create a nice structure to expose them in :D
+static const struct {
+  int (*new)(dog_t*, const char* furColor, const char* size);
+  int (*delete)(dog_t*);
+
+  const char* (*getFurColor)(dog_t*);
+  const char* (*getSize)(dog_t*);
+} Dog = {
+  .new = &dog_new,
+  .delete = &dog_delete,
+  .getFurColor = &dog_getFurColor,
+  .getSize = &dog_getSize
+};
+
+#endif // DOG_H

error.h

@@ -0,0 +1,8 @@
+#ifndef ERROR_H
+#define ERROR_H
+
+#define ERROR_VAL -1
+#define SUCCESS_VAL 0
+#define ERROR (err) { errno = (err); }
+
+#endif // ERROR_H

main.c

@@ -0,0 +1,21 @@
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include "dog.h"
+
+int main (int argc, char* argv[]) {
+  dog_t* dog = malloc(sizeof(dog_t));
+  Dog.new(dog, "white", "small");
+
+  printf("The %s dog has %s fur!\n", Dog.getSize(dog), Dog.getFurColor(dog));
+
+  Animal.speak((animal_t*)dog);
+
+  Dog.delete(dog);
+  free(dog);
+
+  return 0;
+}