Added private variables and a second example object

Author: Christian Howe

Makefile

@@ -1,5 +1,5 @@
 build:
-	gcc main.c animal.c dog.c -o test
+	gcc -g main.c animal.c dog.c -o test
 
 memcheck:
 	valgrind ./test

animal.c

@@ -1,20 +1,42 @@
 #include "animal.h"
 
-int animal_new(animal_t* self, const char* type) {
-  if (type == NULL) {
+typedef struct {
+  char* type;
+} animal_p;
+
+int animal_new(animal_t* self, const char* type, const char* name) {
+  if (type == NULL || name == NULL) {
     return ERROR_VAL;
   }
 
-  self->type = malloc(strlen(type)+1);
-  strcpy(self->type, type);
+  self->vtable.speak = NULL;
+
+  self->name = malloc(strlen(name)+1);
+  strcpy(self->name, name);
+
+  self->private = malloc(sizeof(animal_p));
+  animal_p* private = self->private;
+
+  private->type = malloc(strlen(type) + 1);
+  strcpy(private->type, type);
 
   return SUCCESS_VAL;
 }
 
 int animal_delete(animal_t* self) {
-  if (self->type != NULL) {
-    free(self->type);
-    self->type = NULL;
+  if (self->name != NULL) {
+    free(self->name);
+    self->name = NULL;
+  }
+
+  if (self->private != NULL) {
+    animal_p* private = self->private;
+    if (private->type != NULL) {
+      free(private->type);
+      private->type = NULL;
+    }
+    free(private);
+    self->private = NULL;
   }
 
   return SUCCESS_VAL;
@@ -25,5 +47,10 @@ void animal_speak(animal_t* self) {
     return self->vtable.speak(self);
   }
 
-  printf("This %s cannot speak!", self->type);
+  printf("%s cannot speak. Poor %s!\n", self->name, Animal.getType(self));
+}
+
+const char* animal_getType(animal_t* self) {
+  animal_p* private = self->private;
+  return private->type;
 }

animal.h

@@ -12,25 +12,30 @@ typedef struct {
     void (*speak)(void* self);
   } vtable;
 
-  char* type;
+  void* private;
+  char* name;
 } animal_t;
 
-int animal_new(animal_t* self, const char* type);
+int animal_new(animal_t* self, const char* type, const char* name);
 
 int animal_delete(animal_t* self);
 
 void animal_speak(animal_t* self);
 
+const char* animal_getType(animal_t* self);
+
 // Create a nice structure to expose them in :D
 static const struct {
-  int (*new)(animal_t*, const char*);
+  int (*new)(animal_t*, const char*, const char*);
   int (*delete)(animal_t*);
 
   void (*speak)(animal_t*);
+  const char* (*getType)(animal_t*);
 } Animal = {
   .new = &animal_new,
   .delete = &animal_delete,
   .speak = &animal_speak,
+  .getType = &animal_getType
 };
 
 #endif // ANIMAL_H

dog.c

@@ -1,47 +1,62 @@
 #include "dog.h"
 
+typedef struct {
+  char* furColor;
+  char* size;
+} dog_p;
+
 void dog_speak (void* _self) {
   dog_t* self = _self;
-  printf("'woof!' says the %s %s dog!\n", self->size, self->furColor);
+  printf("'woof!' says the %s %s dog!\n", Dog.getSize(self), Dog.getFurColor(self));
 }
 
-int dog_new (dog_t* self, const char* furColor, const char* size) {
+int dog_new (dog_t* self, const char* name, const char* furColor, const char* size) {
   if (furColor == NULL || size == NULL) {
     return ERROR_VAL;
   }
 
-  Animal.new(&(self->super), "dog");
+  Animal.new(&(self->super), "dog", name);
 
   self->super.vtable.speak = &dog_speak;
 
-  self->furColor = malloc(strlen(furColor) + 1);
-  strcpy(self->furColor, furColor);
+  self->private = malloc(sizeof(dog_p));
+  dog_p* private = self->private;
+
+  private->furColor = malloc(strlen(furColor) + 1);
+  strcpy(private->furColor, furColor);
 
-  self->size = malloc(strlen(size) + 1);
-  strcpy(self->size, size);
+  private->size = malloc(strlen(size) + 1);
+  strcpy(private->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;
+  if (self->private != NULL) {
+    dog_p* private = self->private;
+    if (private->furColor != NULL) {
+      free(private->furColor);
+      private->furColor = NULL;
+    }
+    if (private->size != NULL) {
+      free(private->size);
+      private->size = NULL;
+    }
+    free(private);
+    self->private = NULL;
   }
 
   return SUCCESS_VAL;
 }
 
 const char* dog_getFurColor (dog_t* self) {
-  return self->furColor;
+  dog_p* private = self->private;
+  return private->furColor;
 }
 
 const char* dog_getSize (dog_t* self) {
-  return self->size;
+  dog_p* private = self->private;
+  return private->size;
 }

dog.h

@@ -11,13 +11,12 @@
 
 typedef struct {
   animal_t super;
-  char* furColor;
-  char* size;
+  void* private;
 } 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);
+int dog_new (dog_t* self, const char* name, const char* furColor, const char* size);
 
 // Deletes a dog. Takes pointer to dog created with dog_ctor D:
 int dog_delete (dog_t* self);
@@ -32,7 +31,7 @@ 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 (*new)(dog_t*, const char*, const char*, const char*);
   int (*delete)(dog_t*);
 
   const char* (*getFurColor)(dog_t*);

main.c

@@ -5,11 +5,17 @@
 
 int main (int argc, char* argv[]) {
   dog_t* dog = malloc(sizeof(dog_t));
-  Dog.new(dog, "white", "small");
+  Dog.new(dog, "Scruffy", "white", "small");
 
-  printf("The %s dog has %s fur!\n", Dog.getSize(dog), Dog.getFurColor(dog));
+  animal_t cat;
+  Animal.new(&cat, "cat", "Garfield");
+
+  printf("%s is a %s %s %s!\n", ((animal_t*)dog)->name, Dog.getSize(dog), Dog.getFurColor(dog), Animal.getType((animal_t*)dog));
 
   Animal.speak((animal_t*)dog);
+  Animal.speak(&cat);
+
+  Animal.delete(&cat);
 
   Dog.delete(dog);
   free(dog);