object oriented C - variables in struct + pro's and cons

Question

I am a young student who learned C two years ago. I just discovered more complex things like object oriented C.

My first question is:

1) How do you access your variables? The goal would be to have specific values for those variables depending on the struct which has been instantiated. So I'd like something like:

myStruct* myStrPtr;
myStruct2* myStrPtr;

myStrPtr = initializeStruct();
myStrPtr->printContent //prints for example 55

myStrPtr2 = initializeStruct();
myStrPtr2->printContent //prints for example 6548

example

typedef struct {

    void (*sum)(int a, int b);
    void (*printContent)(void);

    int content;

}myStruct;

void printInhoud(void){
   printf("content: %d\n", content);}

void sum(int a, int b){

 /***********THIS DOESN T WORK OBVIOUSLY************/
    this->content = a+b;
    printf("calculated sum: %d", sum);
  }


myStruct * initializeStruct(void)
{
    myStruct* myStrPtr = malloc(sizeof(myStruct));
    myStrPtr -> foo = foo ; 
    mynStrPtr->printContent = printContent;

    return myStrPtr;
}

 void freeMem(myStruct * myStructPtr)
{
   free(myStructPtr);
}


int main (void)
{
    int a= 1;
    int b=33;

    myStruct* myStrPtr;

    myStrPtr = initializeStruct();

    myStrPtr->printContent();

    return 0;
}

2) my second question is: what are pro's and con's about programming in this way? I think that if I am able to add the variables in the structures and access them just like in OOP, I get a big advantage: modularity. I am active in embedded software and believe that having such an advantage of OOP on an embedded system can be very interesting. I have been criticized for trying to do this. The only reason I was given: "You have no garbage collector, so don't". Could someone give me some pro's and con's and explain why this would be "such an incredibly bad programming practice"

Answer 1

You can do OOP in C, but one of the major cons is that you have to pass the this pointer around. Let's say you have a pointer to a printInfo() function in your struct and you want to print the info of that particular struct. You have to do

my_struct->printInfo(my_struct);

or, if my_struct is not a pointer to your struct

my_struct.printInfo(&my_struct);

There's no way around it.

For your second question, I'm not sure doing OOP in C is really practical. I have done it out of curiosity and it's really fun. You can get inheritance, virtual base classes, polymorphism and all. If you're interested you can check it out here:

https://github.com/vladcc/object-oriented-c

Answer 2

Not only encapsulation, many other OOP concepts can be implemented using C with little bit effort.

Here is an example.

//
// cobj.h
//

#ifndef __COBJ_H__
#define __COBJ_H__
struct _cobj_priv;
typedef struct _cobj {
    struct _cobj_priv *priv;

    void (*set_data)(struct _cobj *obj, int data);
    int (*get_data)(struct _cobj *obj);
    void (*print_data)(struct _cobj *obj);
} cobj_t;

cobj_t *new_struct(void);
void free_struct(cobj_t *obj);

#endif /* __COBJ_H__ */

//
// cobj.c
//

#include "cobj.h"
#include <stdio.h>
#include <stdlib.h>

//
// Internal section
//
struct _cobj_priv {
    int data;
};

static void set_data (struct _cobj *obj, int data) {
    struct _cobj_priv *this = (obj && obj->priv) ? obj->priv: NULL;

    if (this) {
        this->data = data;
    }
}

static int get_data (struct _cobj *obj) {
    struct _cobj_priv *this = (obj && obj->priv) ? obj->priv: NULL;

    return (this)? this->data : 0;
}

static void print_data (struct _cobj *obj) {
    struct _cobj_priv *this = (obj && obj->priv) ? obj->priv: NULL;

    if (this)
        printf("%d\n", this->data);
}

//
// APIs section
//
cobj_t *new_struct(void) {
    cobj_t *obj = malloc(sizeof(cobj_t));

    if (obj) {
        obj->priv = malloc(sizeof(struct _cobj_priv));

        if (obj->priv) {
            obj->priv->data = 0;
        }

        obj->set_data = &set_data;
        obj->get_data = &get_data;
        obj->print_data = &print_data;
    }

    return obj;
}

void free_struct(cobj_t *obj) {
    if (obj) {
        if (obj->priv)
            free(obj->priv);

        free(obj);

        obj = null;
    }
}

//
// main.c
//

#include "cobj.h"
#include <stdio.h>

int main(int argc, char *argv[]) {
    cobj_t *obj = new_struct();

    if (obj) {
        obj->print_data(obj);
        obj->set_data(obj, 100);
        obj->print_data(obj);

        printf("> get data return %d\n", obj->get_data(obj));
    }

    return 0;
}

Result:

0
100
> get data return 100

In C, struct's methods are function pointers, they do not know about the existence of struct so that they can not access to the struct members. You need to pass the struct instance to methods as a parameter in order to access to its members.

Answer 3

Disclaimer: I'm not sure that the following is truely an answer, but it is way too long for a comment.

Is it possible to do OOP in C?

Yes it is. First C++ compilers were mere pre-processors that converted C++ source to C. Of course, you have neither contructors not destructors so you must explicitely call them, you must use composition pattern for inheritance, you must have vtables for virtual methods and must explicitely pass the this pointer.

Simple example with ctor, dtor, a dynamic array and a method:

struct __foo {
    int *arr;
    int n;
};
typedef struct __foo foo;
bool init_foo(foo *f, int n) {
    f->arr = malloc(n * sizeof(int));
    f->n = n;
    return (f->arr != NULL);
}
void clean_foo(foo *f) { free(f->arr); }
bool set(int index, int value, foo *f) {  // same for get...
    if ((index >= f->n) || (index < 0)) return false;
    f->arr[index] = value;
    return true;
}

Usage:

foo f;
init_foo(8, &f);
set(5, 2, &f);
clean_foo(&f);

More complex example with inheritance and virtual method :

typedef struct {
    int age;
    const char *name;
    const char* (*say)(void *);
} animal;
typedef struct {
    animal parent;
} dog;
typedef struct {
    animal parent;
} cat;
void init_animal(int age, const char *name, animal *a) {
    a->age = age;
    a->name = name;
}
char *pre_say(animal *this) {
    char * msg = malloc(strlen(this->name) + 11);
    strcpy(msg, this->name);
    strcat(msg, " says ");
    return msg;

const char * wow(void *an) {
    animal *this = (animal *) an;
    char * msg = pre_say(this);
    strcat(msg, "Woof");
    return msg;
}
const char* meeow(void *an) {
    animal *this = (animal *) an;
    char * msg = pre_say(this);
    strcat(msg, "Meew");
    return msg;
}
void init_dog(int age, const char * name, dog *d) {
    init_animal(age, name, &(d->parent));
    d->say = &woof;
}
void init_cat(int age, const char * name, cat *c) {
    init_animal(age, name, &(c->parent));
    d->say = &meeow;
}

Usage example:

dog d;
init_dog(2, "Rintintin", &d);
cat c;
init_cat(3, "Tom", &c);
const char *msg = (d.say)(&d);  // msg <- Rintintin says Woof
free(msg);
msg = (c.say)(&c);    // msg <- Tom says Meew
free(msg);

Should we do OOP in C?

Definitely NO. As you can say from previous example, as soon as you need polymorphism, pointers must be void * and you loose all possible type checking. And you also loose all the C++ goodies of automatic construtors and destructors, automatic this pointer, etc. You end with much more code, much harder to read and debug. The only acceptable use cases (IMHO) are:

• interfacing C++ and C
• minimal conversion of C++ code for a platform where you have only a C compiler.
• low level codes (kernel or high performance libraries) in which you do not want to be bored with the overhead of C++, and still need OOP.

And just remember: if C++ was invented, it must have been to fill a gap in C language. So don't try to do what C++ was created for in C, unless you really know why you do that.

Has Garbage Collector something to do with OOP?

Here again no. C++ has no garbage collection and is indeed an OO language.