How would one write object-oriented code in C

Question

What are some ways to write object-oriented code in C  Especially with regard to polymorphism     See also this Stack Overflow question Object-orientation in C

User · Answer

I believe that besides being useful in its own right, implementing OOP in C is an excellent way to learn OOP and understand its inner workings. Experience of many programmers has shown that to use a technique efficiently and confidently, a programmer must understand how the underlying concepts are ultimately implemented. Emulating classes, inheritance, and polymorphism in C teaches just this.

To answer the original question, here are a couple resources that teach how to do OOP in C:

EmbeddedGurus.com blog post "Object-based programming in C" shows how to implement classes and single inheritance in portable C: http://embeddedgurus.com/state-space/2008/01/object-based-programming-in-c/

Application Note ""C+"—Object Oriented Programming in C" shows how to implement classes, single inheritance, and late binding (polymorphism) in C using preprocessor macros: http://www.state-machine.com/resources/cplus_3.0_manual.pdf, the example code is available from http://www.state-machine.com/resources/cplus_3.0.zip

User · Answer

I think that the first thing to say is that  IMHO at least  C s implementation of function pointers is REALLY hard to use  I would jump through a WHOLE lot of hoops to avoid function pointers      that said  I think that what other people have said is pretty good  you have structures  you have modules  instead of foo- gt method a b c   you end up with method foo a b c   If you have more than one type with a  method  method  then you can prefix it with the type  so FOO method foo a b c   as others have said    with good use of  h files you can get private and public  etc    Now  there are a few things that this technique WON T give you  It won t give you private data fields  that  I think  you have to do with willpower and good coding hygiene    Also  there isn t an easy way to do inheritance with this    Those are the easy parts at least   the rest  I think is a 90 10 kind of situation  10  of the benefit will require 90  of the work

User · Answer

OOP is only a paradigm which place datas as more important than code in programs  OOP is not a language  So  like plain C is a simple language  OOP in plain C is simple too

User · Answer

Yes  but I have never seen anyone attempt to implement any sort of polymorphism with C

User · Answer

Sure that is possible  This is what GObject  the framework that all of GTK  and GNOME is based on  does

User · Answer

Since you re talking about polymorphism then yes  you can  we were doing that sort of stuff years before C   came about   Basically you use a struct to hold both the data and a list of function pointers to point to the relevant functions for that data   So  in a communications class  you would have an open  read  write and close call which would be maintained as four function pointers in the structure  alongside the data for an object  something like   typedef struct       int   open  void  self  char  fspec       int   close  void  self       int   read  void  self  void  buff  size t max sz  size t  p act sz       int   write  void  self  void  buff  size t max sz  size t  p act sz          And data goes here    tCommClass   tCommClass commRs232  commRs232 open    amp rs232Open      commRs232 write    amp rs232Write   tCommClass commTcp  commTcp open    amp tcpOpen      commTcp write    amp tcpWrite    Of course  those code segments above would actually be in a  constructor  such as rs232Init     When you  inherit  from that class  you just change the pointers to point to your own functions  Everyone that called those functions would do it through the function pointers  giving you your polymorphism   int stat    commTcp open  commTcp   bigiron box com 5000      Sort of like a manual vtable   You could even have virtual classes by setting the pointers to NULL -the behaviour would be slightly different to C    a core dump at run-time rather than an error at compile time    Here s a piece of sample code that demonstrates it  First the top-level class structure    include  lt stdio h gt      The top-level class   typedef struct sCommClass       int   open  struct sCommClass  self  char  fspec     tCommClass    Then we have the functions for the TCP  subclass       Function for the TCP  class    static int tcpOpen  tCommClass  tcp  char  fspec        printf   Opening TCP   s n   fspec       return 0    static int tcpInit  tCommClass  tcp        tcp- gt open    amp tcpOpen      return 0      And the HTTP one as well      Function for the HTTP  class    static int httpOpen  tCommClass  http  char  fspec        printf   Opening HTTP   s n   fspec       return 0    static int httpInit  tCommClass  http        http- gt open    amp httpOpen      return 0      And finally a test program to show it in action      Test program   int main  void        int status      tCommClass commTcp  commHttp          Same  base  class but initialised to different sub-classes       tcpInit   amp commTcp       httpInit   amp commHttp           Called in exactly the same manner       status    commTcp open   amp commTcp   bigiron box com 5000        status    commHttp open   amp commHttp   http   www microsoft com         return 0      This produces the output   Opening TCP  bigiron box com 5000 Opening HTTP  http   www microsoft com   so you can see that the different functions are being called  depending on the sub-class

User · Answer

Yes  In fact Axel Schreiner provides his book  Object-oriented Programming in ANSI-C  for free which covers the subject quite thoroughly

User · Answer

Yes  but I have never seen anyone attempt to implement any sort of polymorphism with C

User · Answer

Of course  it just won t be as pretty as using a language with built-in support  I ve even written  object-oriented assembler

User · Answer

I propose to use Objective-C  which is a superset of C    While Objective-C is 30 years old  it allows to write elegant code   http   en wikipedia org wiki Objective-C

User · Answer

I propose to use Objective-C  which is a superset of C    While Objective-C is 30 years old  it allows to write elegant code   http   en wikipedia org wiki Objective-C

User · Answer

Trivial example with an Animal and Dog  You mirror C   s vtable mechanism  largely anyway   You also separate allocation and instantiation  Animal Alloc  Animal New  so we don t call malloc   multiple times  We must also explicitly pass the this pointer around   If you were to do non-virtual functions  that s trival  You just don t add them to the vtable and static functions don t require a this pointer  Multiple inheritance generally requires multiple vtables to resolve ambiguities   Also  you should be able to use setjmp longjmp to do exception handling   struct Animal Vtable      typedef void   Walk Fun  struct Animal  a This       typedef struct Animal     Dtor Fun  struct Animal  a This        Walk Fun Walk      Dtor Fun Dtor      struct Animal      Animal Vtable vtable       char  Name      struct Dog      Animal Vtable vtable       char  Name     Mirror member variables for easy access     char  Type      void Animal Walk struct Animal  a This       printf  Animal   s  walking n   a This- gt Name      struct Animal  Animal Dtor struct Animal  a This       printf  animal  dtor n        return a This     Animal  Animal Alloc        return  Animal  malloc sizeof Animal       Animal  Animal New Animal  a Animal       a Animal- gt vtable Walk   Animal Walk      a Animal- gt vtable Dtor   Animal Dtor      a Animal- gt Name    Anonymous       return a Animal     void Animal Free Animal  a This       a This- gt vtable Dtor a This        free a This      void Dog Walk struct Dog  a This       printf  Dog walking  s   s  n   a This- gt Type  a This- gt Name      Dog  Dog Dtor struct Dog  a This          Explicit call to parent destructor     Animal Dtor  Animal  a This        printf  dog  dtor n         return a This     Dog  Dog Alloc        return  Dog  malloc sizeof Dog       Dog  Dog New Dog  a Dog          Explict call to parent constructor     Animal New  Animal  a Dog        a Dog- gt Type    Dog type       a Dog- gt vtable Walk    Animal Vtable  Walk Fun  Dog Walk      a Dog- gt vtable Dtor    Animal Vtable  Dtor Fun  Dog Dtor       return a Dog     int main int argc  char   argv                Base class           Animal  a Animal   Animal New Animal Alloc                Animal  a Animal    Animal  Dog New Dog Alloc          a Animal- gt vtable Walk a Animal        Animal Free a Animal       PS  This is tested on a C   compiler  but it should be easy to make it work on a C compiler

User · Answer

There is an example of inheritance using C in Jim Larson s 1996 talk given at the Section 312 Programming Lunchtime Seminar here  High and Low-Level C

User · Answer

I ve been digging this for one year   As the GObject system is hard to use with pure C  I tried to write some nice macros to ease the OO style with C    include  OOStd h   CLASS Animal        char  name      STATIC Animal       vFn talk     static int Animal load Animal  THIS void  name        THIS- gt name   name      return 0    ASM Animal  Animal load  NULL  NULL  NULL   CLASS EX Cat Animal        STATIC EX Cat  Animal      static void Meow Animal  THIS       printf  Meow My name is  s  n   THIS- gt name      static int Cat loadSt StAnimal  THIS  void  PARAM       THIS- gt talk    void   Meow      return 0    ASM EX Cat Animal  NULL  NULL  Cat loadSt  NULL    CLASS EX Dog Animal       STATIC EX Dog  Animal       static void Woof Animal  THIS       printf  Woof My name is  s  n   THIS- gt name      static int Dog loadSt StAnimal  THIS  void  PARAM        THIS- gt talk    void   Woof      return 0    ASM EX Dog  Animal  NULL  NULL  Dog loadSt  NULL   int main        Animal  animals 4000       StAnimal  f      int i   0      for  i 0  i lt 4000  i                  if i 2  0              animals i    NEW Dog  Jack            else             animals i    NEW Cat  Lily               f   ST animals 0        for i 0  i lt 4000    i            f- gt talk animals i              for  i 0  i lt 4000    i            DELETE0 animals i              return 0      Here is my project site  I don t have enough time to write en  doc however the doc in chinese is much better    OOC-GCC

User · Answer

Object oriented C  can be done  I ve seen that type of code in production in Korea  and it was the most horrible monster I d seen in years  this was like last year 2007  that I saw the code   So yes it can be done  and yes people have done it before  and still do it even in this day and age  But I d recommend C   or Objective-C  both are languages born from C  with the purpose of providing object orientation with different paradigms

User · Answer

I ve seen it done   I wouldn t recommend it   C   originally started this way as a preprocessor that produced C code as an intermediate step   Essentially what you end up doing is create a dispatch table for all of your methods where you store your function references   Deriving a class would entail copying this dispatch table and replacing the entries that you wanted to override  with your new  methods  having to call the original method if it wants to invoke the base method   Eventually  you end up rewriting C

User · Answer

I ve seen it done   I wouldn t recommend it   C   originally started this way as a preprocessor that produced C code as an intermediate step   Essentially what you end up doing is create a dispatch table for all of your methods where you store your function references   Deriving a class would entail copying this dispatch table and replacing the entries that you wanted to override  with your new  methods  having to call the original method if it wants to invoke the base method   Eventually  you end up rewriting C

User · Answer

You can fake it using function pointers  and in fact  I think it is theoretically possible to compile C   programs into C   However  it rarely makes sense to force a paradigm on a language rather than to pick a language that uses a paradigm

User · Answer

Since you re talking about polymorphism then yes  you can  we were doing that sort of stuff years before C   came about   Basically you use a struct to hold both the data and a list of function pointers to point to the relevant functions for that data   So  in a communications class  you would have an open  read  write and close call which would be maintained as four function pointers in the structure  alongside the data for an object  something like   typedef struct       int   open  void  self  char  fspec       int   close  void  self       int   read  void  self  void  buff  size t max sz  size t  p act sz       int   write  void  self  void  buff  size t max sz  size t  p act sz          And data goes here    tCommClass   tCommClass commRs232  commRs232 open    amp rs232Open      commRs232 write    amp rs232Write   tCommClass commTcp  commTcp open    amp tcpOpen      commTcp write    amp tcpWrite    Of course  those code segments above would actually be in a  constructor  such as rs232Init     When you  inherit  from that class  you just change the pointers to point to your own functions  Everyone that called those functions would do it through the function pointers  giving you your polymorphism   int stat    commTcp open  commTcp   bigiron box com 5000      Sort of like a manual vtable   You could even have virtual classes by setting the pointers to NULL -the behaviour would be slightly different to C    a core dump at run-time rather than an error at compile time    Here s a piece of sample code that demonstrates it  First the top-level class structure    include  lt stdio h gt      The top-level class   typedef struct sCommClass       int   open  struct sCommClass  self  char  fspec     tCommClass    Then we have the functions for the TCP  subclass       Function for the TCP  class    static int tcpOpen  tCommClass  tcp  char  fspec        printf   Opening TCP   s n   fspec       return 0    static int tcpInit  tCommClass  tcp        tcp- gt open    amp tcpOpen      return 0      And the HTTP one as well      Function for the HTTP  class    static int httpOpen  tCommClass  http  char  fspec        printf   Opening HTTP   s n   fspec       return 0    static int httpInit  tCommClass  http        http- gt open    amp httpOpen      return 0      And finally a test program to show it in action      Test program   int main  void        int status      tCommClass commTcp  commHttp          Same  base  class but initialised to different sub-classes       tcpInit   amp commTcp       httpInit   amp commHttp           Called in exactly the same manner       status    commTcp open   amp commTcp   bigiron box com 5000        status    commHttp open   amp commHttp   http   www microsoft com         return 0      This produces the output   Opening TCP  bigiron box com 5000 Opening HTTP  http   www microsoft com   so you can see that the different functions are being called  depending on the sub-class

User · Answer

Sure that is possible  This is what GObject  the framework that all of GTK  and GNOME is based on  does

User · Answer

Of course  it just won t be as pretty as using a language with built-in support  I ve even written  object-oriented assembler

User · Answer

I m a bit late to the party  but I want to share my experience on the topic  I work with embedded stuff these days  and the only  reliable  compiler I have is C  so that I want to apply object-oriented approach in my embedded projects written in C   Most of the solutions I ve seen so far use typecasts heavily  so we lose type safety  compiler won t help you if you make a mistake  This is completely unacceptable    Requirements that I have    Avoid typecasts as much as possible  so we don t lose type safety  Polymorphism  we should be able to use virtual methods  and user of the class should not be aware whether some particular method is virtual or not  Multiple inheritance  I don t use it often  but sometimes I really want some class to implement multiple interfaces  or to extend multiple superclasses     I ve explained my approach in detail in this article  Object-oriented programming in C  plus  there is an utility for autogeneration of boilerplate code for base and derived classes

User · Answer

Of course  it just won t be as pretty as using a language with built-in support  I ve even written  object-oriented assembler

User · Answer

A little OOC code to add    include  lt stdio h gt   struct Node       int somevar      void print         printf  Hello from an object-oriented C method         struct Tree       struct Node   NIL      void   FPprint  void       struct Node  root      struct Node NIL t    TreeA     amp TreeA NIL t print    int main         struct Tree TreeB      TreeB   TreeA      TreeB FPprint        return 0

User · Answer

I ve seen it done   I wouldn t recommend it   C   originally started this way as a preprocessor that produced C code as an intermediate step   Essentially what you end up doing is create a dispatch table for all of your methods where you store your function references   Deriving a class would entail copying this dispatch table and replacing the entries that you wanted to override  with your new  methods  having to call the original method if it wants to invoke the base method   Eventually  you end up rewriting C

User · Answer

Which articles or books are good to use OOP concepts in C    Dave Hanson s C Interfaces and Implementations is excellent on encapsulation and naming and very good on use of function pointers    Dave does not try to simulate inheritance

User · Answer

Yes  you can  People were writing object-oriented C before C   or Objective-C came on the scene  Both C   and Objective-C were  in parts  attempts to take some of the OO concepts used in C and formalize them as part of the language   Here s a really simple program that shows how you can make something that looks-like is a method call  there are better ways to do this  This is just proof the language supports the concepts     include lt stdio h gt   struct foobarbaz      int one      int two      int three      int   exampleMethod  int  int       int addTwoNumbers int a  int b       return a b     int main            Define the function pointer     int   pointerToFunction  int  int    addTwoNumbers          Let s make sure we can call the pointer     int test     pointerToFunction  12 12       printf   test   u  n    test           Now  define an instance of our struct        and add some default values      struct foobarbaz fbb      fbb one     1      fbb two     2      fbb three   3          Now add a  method      fbb exampleMethod   addTwoNumbers          Try calling the method     int test2   fbb exampleMethod 13 36       printf   test2   u  n    test2        printf   nDone n        return 0

User · Answer

Since you re talking about polymorphism then yes  you can  we were doing that sort of stuff years before C   came about   Basically you use a struct to hold both the data and a list of function pointers to point to the relevant functions for that data   So  in a communications class  you would have an open  read  write and close call which would be maintained as four function pointers in the structure  alongside the data for an object  something like   typedef struct       int   open  void  self  char  fspec       int   close  void  self       int   read  void  self  void  buff  size t max sz  size t  p act sz       int   write  void  self  void  buff  size t max sz  size t  p act sz          And data goes here    tCommClass   tCommClass commRs232  commRs232 open    amp rs232Open      commRs232 write    amp rs232Write   tCommClass commTcp  commTcp open    amp tcpOpen      commTcp write    amp tcpWrite    Of course  those code segments above would actually be in a  constructor  such as rs232Init     When you  inherit  from that class  you just change the pointers to point to your own functions  Everyone that called those functions would do it through the function pointers  giving you your polymorphism   int stat    commTcp open  commTcp   bigiron box com 5000      Sort of like a manual vtable   You could even have virtual classes by setting the pointers to NULL -the behaviour would be slightly different to C    a core dump at run-time rather than an error at compile time    Here s a piece of sample code that demonstrates it  First the top-level class structure    include  lt stdio h gt      The top-level class   typedef struct sCommClass       int   open  struct sCommClass  self  char  fspec     tCommClass    Then we have the functions for the TCP  subclass       Function for the TCP  class    static int tcpOpen  tCommClass  tcp  char  fspec        printf   Opening TCP   s n   fspec       return 0    static int tcpInit  tCommClass  tcp        tcp- gt open    amp tcpOpen      return 0      And the HTTP one as well      Function for the HTTP  class    static int httpOpen  tCommClass  http  char  fspec        printf   Opening HTTP   s n   fspec       return 0    static int httpInit  tCommClass  http        http- gt open    amp httpOpen      return 0      And finally a test program to show it in action      Test program   int main  void        int status      tCommClass commTcp  commHttp          Same  base  class but initialised to different sub-classes       tcpInit   amp commTcp       httpInit   amp commHttp           Called in exactly the same manner       status    commTcp open   amp commTcp   bigiron box com 5000        status    commHttp open   amp commHttp   http   www microsoft com         return 0      This produces the output   Opening TCP  bigiron box com 5000 Opening HTTP  http   www microsoft com   so you can see that the different functions are being called  depending on the sub-class

User · Answer

OOP is only a paradigm which place datas as more important than code in programs  OOP is not a language  So  like plain C is a simple language  OOP in plain C is simple too

User · Answer

There are several techniques that can be used  The most important one is more how to split the project  We use an interface in our project that is declared in a  h file and the implementation of the object in a  c file  The important part is that all modules that include the  h file see only an object as a void    and the  c file is the only module who knows the internals of the structure   Something like this for a class we name FOO as an example   In the  h file   ifndef FOO H   define FOO H        typedef struct FOO type FOO type         That s all the rest of the program knows about FOO        Declaration of accessors  functions    FOO type  FOO new void   void FOO free FOO type  this       void FOO dosomething FOO type  this  param       char  FOO getName FOO type  this  etc    endif   The C implementation file will be something like that    include  lt stdlib h gt       include  FOO h   struct FOO type       whatever         FOO type  FOO new void        FOO type  this   calloc 1  sizeof  FOO type                 FOO dosomething this         return this      So I give the pointer explicitly to an object to every function of that module  A C   compiler does it implicitly  and in C we write it explicitly out   I really use this in my programs  to make sure that my program does not compile in C    and it has the fine property of being in another color in my syntax highlighting editor   The fields of the FOO struct can be modified in one module and another module doesn t even need to be recompiled to be still usable   With that style I already handle a big part of the advantages of OOP  data encapsulation   By using function pointers  it s even easy to implement something like inheritance  but honestly  it s really only rarely useful

User · Answer

The C stdio FILE sub-library is an excellent example of how to create abstraction  encapsulation  and modularity in unadulterated C    Inheritance and polymorphism - the other aspects often considered essential to OOP - do not necessarily provide the productivity gains they promise and reasonable arguments have been made that they can actually hinder development and thinking about the problem domain

User · Answer

I built a little library where I tried that and to me it works real nicely  So I thought I share the experience   https   github com thomasfuhringer oxygen  Single inheritance can be implemented quite easily using a struct and extending it for every other child class  A simple cast to the parent structure makes it possible to use parent methods on all the descendants  As long as you know that a variable points to a struct holding this kind of an object you can always cast to the root class and do introspection   As has been mentioned  virtual methods are somewhat trickier  But they are doable  To keep things simple I just use an array of functions in the class description structure which every child class copies and repopulates individual slots where required   Multiple inheritance would be rather complicated to implement and comes with a significant performance impact  So I leave it  I do consider it desirable and useful in quite a few cases to cleanly model real life circumstances  but in probably 90  of cases single inheritance covers the needs  And single inheritance is simple and costs nothing    Also I do not care about type safety  I think you should not depend on the compiler to prevent you from programming mistakes  And it shields you only from a rather small part of errors anyway   Typically  in an object oriented environment you also want to implement reference counting to automate memory management to the extent possible  So I also put a reference count into the    Object    root class and some functionality to encapsulate allocation and deallocation of heap memory   It is all very simple and lean and gives me the essentials of OO without forcing me to deal with the monster that is C    And I retain the flexibility of staying in C land  which among other things makes it easier to integrate third party libraries

User · Answer

Yes  you can  People were writing object-oriented C before C   or Objective-C came on the scene  Both C   and Objective-C were  in parts  attempts to take some of the OO concepts used in C and formalize them as part of the language   Here s a really simple program that shows how you can make something that looks-like is a method call  there are better ways to do this  This is just proof the language supports the concepts     include lt stdio h gt   struct foobarbaz      int one      int two      int three      int   exampleMethod  int  int       int addTwoNumbers int a  int b       return a b     int main            Define the function pointer     int   pointerToFunction  int  int    addTwoNumbers          Let s make sure we can call the pointer     int test     pointerToFunction  12 12       printf   test   u  n    test           Now  define an instance of our struct        and add some default values      struct foobarbaz fbb      fbb one     1      fbb two     2      fbb three   3          Now add a  method      fbb exampleMethod   addTwoNumbers          Try calling the method     int test2   fbb exampleMethod 13 36       printf   test2   u  n    test2        printf   nDone n        return 0

User · Answer

I ve seen it done   I wouldn t recommend it   C   originally started this way as a preprocessor that produced C code as an intermediate step   Essentially what you end up doing is create a dispatch table for all of your methods where you store your function references   Deriving a class would entail copying this dispatch table and replacing the entries that you wanted to override  with your new  methods  having to call the original method if it wants to invoke the base method   Eventually  you end up rewriting C

User · Answer

See http   slkpg byethost7 com instance html for yet another twist on OOP in C  It emphasizes instance data for reentrancy using just native C  Multiple inheritance is done manually using function wrappers  Type safety is maintained  Here is a small sample   typedef struct  peeker       log t      log      symbols t  sym      scanner t  scan                inherited instance     peek t     pk      int        trace       void      push    SELF  d  symbol t  symbol        short     peek    SELF  d  int level        short     get     SELF  d        int       get line number    SELF  d       peeker t  SlkToken    define push self a               self  push self  a   define peek self a               self  peek self  a   define get self                  self  get self   define get line number self      self  get line number self   INSTANCE METHOD int  get line number    peeker t  d         return  d- gt scan line number     PUBLIC void InitializePeeker   peeker t   peeker                     int        trace                     symbols t  symbols                     log t      log                     list t     list         InitializeScanner    amp peeker- gt scan  trace  symbols  log  list        peeker- gt log   log      peeker- gt sym   symbols      peeker- gt pk current   peeker- gt pk buffer      peeker- gt pk count   0      peeker- gt trace   trace       peeker- gt get line number   get line number      peeker- gt push   push      peeker- gt get   get      peeker- gt peek   peek

User · Answer

Yes  you can  People were writing object-oriented C before C   or Objective-C came on the scene  Both C   and Objective-C were  in parts  attempts to take some of the OO concepts used in C and formalize them as part of the language   Here s a really simple program that shows how you can make something that looks-like is a method call  there are better ways to do this  This is just proof the language supports the concepts     include lt stdio h gt   struct foobarbaz      int one      int two      int three      int   exampleMethod  int  int       int addTwoNumbers int a  int b       return a b     int main            Define the function pointer     int   pointerToFunction  int  int    addTwoNumbers          Let s make sure we can call the pointer     int test     pointerToFunction  12 12       printf   test   u  n    test           Now  define an instance of our struct        and add some default values      struct foobarbaz fbb      fbb one     1      fbb two     2      fbb three   3          Now add a  method      fbb exampleMethod   addTwoNumbers          Try calling the method     int test2   fbb exampleMethod 13 36       printf   test2   u  n    test2        printf   nDone n        return 0

User · Answer

I think that the first thing to say is that  IMHO at least  C s implementation of function pointers is REALLY hard to use  I would jump through a WHOLE lot of hoops to avoid function pointers      that said  I think that what other people have said is pretty good  you have structures  you have modules  instead of foo- gt method a b c   you end up with method foo a b c   If you have more than one type with a  method  method  then you can prefix it with the type  so FOO method foo a b c   as others have said    with good use of  h files you can get private and public  etc    Now  there are a few things that this technique WON T give you  It won t give you private data fields  that  I think  you have to do with willpower and good coding hygiene    Also  there isn t an easy way to do inheritance with this    Those are the easy parts at least   the rest  I think is a 90 10 kind of situation  10  of the benefit will require 90  of the work

User · Answer

This has been interesting to read  I have been pondering the same question myself  and the benefits of thinking about it are this    Trying to imagine how to implement OOP concepts in a non-OOP language helps me understand the strengths of the OOp language  in my case  C     This helps give me better judgement about whether to use C or C   for a given type of application -- where the benefits of one out-weighs the other  In my browsing the web for information and opinions on this I found an author who was writing code for an embedded processor and only had a C compiler available  http   www eetimes com discussion other 4024626 Object-Oriented-C-Creating-Foundation-Classes-Part-1   In his case  analyzing and adapting OOP concepts in plain C was a valid pursuit  It appears he was open to sacrificing some OOP concepts due to the performance overhead hit resulting from attempting to implement them in C   The lesson I ve taken is  yes it can be done to a certain degree  and yes  there are some good reasons to attempt it   In the end  the machine is twiddling stack pointer bits  making the program counter jump around and calculating memory access operations   From the efficiency standpoint  the fewer of these calculations done by your program  the better    but sometimes we have to pay this tax simply so we can organize our program in a way that makes it least susceptible to human error  The OOP language compiler strives to optimize both aspects  The programmer has to be much more careful implementing these concepts in a language like C

User · Answer

Yes  In fact Axel Schreiner provides his book  Object-oriented Programming in ANSI-C  for free which covers the subject quite thoroughly

User · Answer

Trivial example with an Animal and Dog  You mirror C   s vtable mechanism  largely anyway   You also separate allocation and instantiation  Animal Alloc  Animal New  so we don t call malloc   multiple times  We must also explicitly pass the this pointer around   If you were to do non-virtual functions  that s trival  You just don t add them to the vtable and static functions don t require a this pointer  Multiple inheritance generally requires multiple vtables to resolve ambiguities   Also  you should be able to use setjmp longjmp to do exception handling   struct Animal Vtable      typedef void   Walk Fun  struct Animal  a This       typedef struct Animal     Dtor Fun  struct Animal  a This        Walk Fun Walk      Dtor Fun Dtor      struct Animal      Animal Vtable vtable       char  Name      struct Dog      Animal Vtable vtable       char  Name     Mirror member variables for easy access     char  Type      void Animal Walk struct Animal  a This       printf  Animal   s  walking n   a This- gt Name      struct Animal  Animal Dtor struct Animal  a This       printf  animal  dtor n        return a This     Animal  Animal Alloc        return  Animal  malloc sizeof Animal       Animal  Animal New Animal  a Animal       a Animal- gt vtable Walk   Animal Walk      a Animal- gt vtable Dtor   Animal Dtor      a Animal- gt Name    Anonymous       return a Animal     void Animal Free Animal  a This       a This- gt vtable Dtor a This        free a This      void Dog Walk struct Dog  a This       printf  Dog walking  s   s  n   a This- gt Type  a This- gt Name      Dog  Dog Dtor struct Dog  a This          Explicit call to parent destructor     Animal Dtor  Animal  a This        printf  dog  dtor n         return a This     Dog  Dog Alloc        return  Dog  malloc sizeof Dog       Dog  Dog New Dog  a Dog          Explict call to parent constructor     Animal New  Animal  a Dog        a Dog- gt Type    Dog type       a Dog- gt vtable Walk    Animal Vtable  Walk Fun  Dog Walk      a Dog- gt vtable Dtor    Animal Vtable  Dtor Fun  Dog Dtor       return a Dog     int main int argc  char   argv                Base class           Animal  a Animal   Animal New Animal Alloc                Animal  a Animal    Animal  Dog New Dog Alloc          a Animal- gt vtable Walk a Animal        Animal Free a Animal       PS  This is tested on a C   compiler  but it should be easy to make it work on a C compiler

User · Answer

Check out GObject   It s meant to be OO in C and one implementation of what you re looking for   If you really want OO though  go with C   or some other OOP language   GObject can be really tough to work with at times if you re used to dealing with OO languages  but like anything  you ll get used to the conventions and flow

User · Answer

Sure that is possible  This is what GObject  the framework that all of GTK  and GNOME is based on  does

User · Answer

There are several techniques that can be used  The most important one is more how to split the project  We use an interface in our project that is declared in a  h file and the implementation of the object in a  c file  The important part is that all modules that include the  h file see only an object as a void    and the  c file is the only module who knows the internals of the structure   Something like this for a class we name FOO as an example   In the  h file   ifndef FOO H   define FOO H        typedef struct FOO type FOO type         That s all the rest of the program knows about FOO        Declaration of accessors  functions    FOO type  FOO new void   void FOO free FOO type  this       void FOO dosomething FOO type  this  param       char  FOO getName FOO type  this  etc    endif   The C implementation file will be something like that    include  lt stdlib h gt       include  FOO h   struct FOO type       whatever         FOO type  FOO new void        FOO type  this   calloc 1  sizeof  FOO type                 FOO dosomething this         return this      So I give the pointer explicitly to an object to every function of that module  A C   compiler does it implicitly  and in C we write it explicitly out   I really use this in my programs  to make sure that my program does not compile in C    and it has the fine property of being in another color in my syntax highlighting editor   The fields of the FOO struct can be modified in one module and another module doesn t even need to be recompiled to be still usable   With that style I already handle a big part of the advantages of OOP  data encapsulation   By using function pointers  it s even easy to implement something like inheritance  but honestly  it s really only rarely useful

User · Answer

It s seem like people are trying emulate the C   style using C  My take is that doing object-oriented programming C is really doing struct-oriented programming  However  you can achieve things like late binding  encapsulation  and inheritance  For inheritance you explicitly define a pointer to the base structs in your sub struct and this is obviously a form of multiple inheritance  You ll also need to determine if your    private class h struct private class  extern struct private class   new private class    extern int ret a value struct private class    int a  int b   extern void delete private class struct private class     void   late bind function  struct private class  p      private class c struct inherited class 1  struct inherited class 2   struct private class     int a    int b    struct inherited class 1  p1    struct inherited class 2  p2      struct inherited class 1   new inherited class 1    struct inherited class 2   new inherited class 2     struct private class   new private class       struct private class  p    p    struct private class   malloc sizeof struct private class      p- gt a   0    p- gt b   0    p- gt p1   new inherited class 1      p- gt p2   new inherited class 2      return p         int ret a value struct private class  p  int a  int b          return p- gt a   p- gt b   a   b             void delete private class struct private class  p            release any resources         call delete methods for inherited classes       free p               main c     struct private class  p      p   new private class        late bind function    amp implementation function      delete private class p     compile with c compiler main c inherited class 1 obj inherited class 2 obj  private class obj   So the advice is to stick to a pure C style and not try to force into a C   style  Also this way lends itself to a very clean way of building an API

User · Answer

There is an example of inheritance using C in Jim Larson s 1996 talk given at the Section 312 Programming Lunchtime Seminar here  High and Low-Level C

User · Answer

Which articles or books are good to use OOP concepts in C    Dave Hanson s C Interfaces and Implementations is excellent on encapsulation and naming and very good on use of function pointers    Dave does not try to simulate inheritance

User · Answer

There is an example of inheritance using C in Jim Larson s 1996 talk given at the Section 312 Programming Lunchtime Seminar here  High and Low-Level C

User · Answer

I m a bit late to the party  but I want to share my experience on the topic  I work with embedded stuff these days  and the only  reliable  compiler I have is C  so that I want to apply object-oriented approach in my embedded projects written in C   Most of the solutions I ve seen so far use typecasts heavily  so we lose type safety  compiler won t help you if you make a mistake  This is completely unacceptable    Requirements that I have    Avoid typecasts as much as possible  so we don t lose type safety  Polymorphism  we should be able to use virtual methods  and user of the class should not be aware whether some particular method is virtual or not  Multiple inheritance  I don t use it often  but sometimes I really want some class to implement multiple interfaces  or to extend multiple superclasses     I ve explained my approach in detail in this article  Object-oriented programming in C  plus  there is an utility for autogeneration of boilerplate code for base and derived classes

User · Answer

I built a little library where I tried that and to me it works real nicely  So I thought I share the experience   https   github com thomasfuhringer oxygen  Single inheritance can be implemented quite easily using a struct and extending it for every other child class  A simple cast to the parent structure makes it possible to use parent methods on all the descendants  As long as you know that a variable points to a struct holding this kind of an object you can always cast to the root class and do introspection   As has been mentioned  virtual methods are somewhat trickier  But they are doable  To keep things simple I just use an array of functions in the class description structure which every child class copies and repopulates individual slots where required   Multiple inheritance would be rather complicated to implement and comes with a significant performance impact  So I leave it  I do consider it desirable and useful in quite a few cases to cleanly model real life circumstances  but in probably 90  of cases single inheritance covers the needs  And single inheritance is simple and costs nothing    Also I do not care about type safety  I think you should not depend on the compiler to prevent you from programming mistakes  And it shields you only from a rather small part of errors anyway   Typically  in an object oriented environment you also want to implement reference counting to automate memory management to the extent possible  So I also put a reference count into the    Object    root class and some functionality to encapsulate allocation and deallocation of heap memory   It is all very simple and lean and gives me the essentials of OO without forcing me to deal with the monster that is C    And I retain the flexibility of staying in C land  which among other things makes it easier to integrate third party libraries

User · Answer

The answer to the question is  Yes  you can    Object-oriented C  OOC  kit is for those who want to program in an object-oriented manner  but sticks on the good old C as well  OOC implements classes  single and multiple inheritance  exception handling   Features      Uses only C macros and functions  no language extensions required   ANSI-C       Easy-to-read source code for your application  Care was taken to make things as simple as possible       Single inheritance of classes      Multiple inheritance by interfaces and mixins  since version 1 3       Implementing exceptions  in pure C        Virtual functions for classes      External tool for easy class implementation  For more details  visit http   ooc-coding sourceforge net

User · Answer

I ve been digging this for one year   As the GObject system is hard to use with pure C  I tried to write some nice macros to ease the OO style with C    include  OOStd h   CLASS Animal        char  name      STATIC Animal       vFn talk     static int Animal load Animal  THIS void  name        THIS- gt name   name      return 0    ASM Animal  Animal load  NULL  NULL  NULL   CLASS EX Cat Animal        STATIC EX Cat  Animal      static void Meow Animal  THIS       printf  Meow My name is  s  n   THIS- gt name      static int Cat loadSt StAnimal  THIS  void  PARAM       THIS- gt talk    void   Meow      return 0    ASM EX Cat Animal  NULL  NULL  Cat loadSt  NULL    CLASS EX Dog Animal       STATIC EX Dog  Animal       static void Woof Animal  THIS       printf  Woof My name is  s  n   THIS- gt name      static int Dog loadSt StAnimal  THIS  void  PARAM        THIS- gt talk    void   Woof      return 0    ASM EX Dog  Animal  NULL  NULL  Dog loadSt  NULL   int main        Animal  animals 4000       StAnimal  f      int i   0      for  i 0  i lt 4000  i                  if i 2  0              animals i    NEW Dog  Jack            else             animals i    NEW Cat  Lily               f   ST animals 0        for i 0  i lt 4000    i            f- gt talk animals i              for  i 0  i lt 4000    i            DELETE0 animals i              return 0      Here is my project site  I don t have enough time to write en  doc however the doc in chinese is much better    OOC-GCC

User · Answer

If you are convinced that an OOP approach is superior for the problem you are trying to solve  why would you be trying to solve it with a non-OOP language  It seems like you re using the wrong tool for the job  Use C   or some other object-oriented C variant language   If you are asking because you are starting to code on an already existing large project written in C  then you shouldn t try to force your own  or anyone else s  OOP paradigms into the project s infrastructure  Follow the guidelines that are already present in the project  In general  clean APIs and isolated libraries and modules will go a long way towards having a clean OOP-ish design   If  after all this  you really are set on doing OOP C  read this  PDF

User · Answer

Object oriented C  can be done  I ve seen that type of code in production in Korea  and it was the most horrible monster I d seen in years  this was like last year 2007  that I saw the code   So yes it can be done  and yes people have done it before  and still do it even in this day and age  But I d recommend C   or Objective-C  both are languages born from C  with the purpose of providing object orientation with different paradigms

User · Answer

Yes  In fact Axel Schreiner provides his book  Object-oriented Programming in ANSI-C  for free which covers the subject quite thoroughly

User · Answer

Yes  but I have never seen anyone attempt to implement any sort of polymorphism with C

User · Answer

Yes  In fact Axel Schreiner provides his book  Object-oriented Programming in ANSI-C  for free which covers the subject quite thoroughly

User · Answer

See http   slkpg byethost7 com instance html for yet another twist on OOP in C  It emphasizes instance data for reentrancy using just native C  Multiple inheritance is done manually using function wrappers  Type safety is maintained  Here is a small sample   typedef struct  peeker       log t      log      symbols t  sym      scanner t  scan                inherited instance     peek t     pk      int        trace       void      push    SELF  d  symbol t  symbol        short     peek    SELF  d  int level        short     get     SELF  d        int       get line number    SELF  d       peeker t  SlkToken    define push self a               self  push self  a   define peek self a               self  peek self  a   define get self                  self  get self   define get line number self      self  get line number self   INSTANCE METHOD int  get line number    peeker t  d         return  d- gt scan line number     PUBLIC void InitializePeeker   peeker t   peeker                     int        trace                     symbols t  symbols                     log t      log                     list t     list         InitializeScanner    amp peeker- gt scan  trace  symbols  log  list        peeker- gt log   log      peeker- gt sym   symbols      peeker- gt pk current   peeker- gt pk buffer      peeker- gt pk count   0      peeker- gt trace   trace       peeker- gt get line number   get line number      peeker- gt push   push      peeker- gt get   get      peeker- gt peek   peek

User · Answer

Yes  it is possible   This is pure C  no macros preprocessing  It has inheritance  polymorphism  data encapsulation  including private data   It does not have equivalent protected qualifier  wich means private data is private down the inheritance chain too    include  triangle h   include  rectangle h   include  polygon h    include  lt stdio h gt   int main         Triangle tr1  CTriangle- gt new        Rectangle rc1  CRectangle- gt new         tr1- gt width  rc1- gt width  3 2      tr1- gt height  rc1- gt height  4 1       CPolygon- gt printArea  Polygon tr1        printf   n         CPolygon- gt printArea  Polygon rc1        output  6 56 13 12

User · Answer

Check out GObject   It s meant to be OO in C and one implementation of what you re looking for   If you really want OO though  go with C   or some other OOP language   GObject can be really tough to work with at times if you re used to dealing with OO languages  but like anything  you ll get used to the conventions and flow

User · Answer

I believe that besides being useful in its own right, implementing OOP in C is an excellent way to learn OOP and understand its inner workings. Experience of many programmers has shown that to use a technique efficiently and confidently, a programmer must understand how the underlying concepts are ultimately implemented. Emulating classes, inheritance, and polymorphism in C teaches just this.

To answer the original question, here are a couple resources that teach how to do OOP in C:

EmbeddedGurus.com blog post "Object-based programming in C" shows how to implement classes and single inheritance in portable C: http://embeddedgurus.com/state-space/2008/01/object-based-programming-in-c/

Application Note ""C+"—Object Oriented Programming in C" shows how to implement classes, single inheritance, and late binding (polymorphism) in C using preprocessor macros: http://www.state-machine.com/resources/cplus_3.0_manual.pdf, the example code is available from http://www.state-machine.com/resources/cplus_3.0.zip

User · Answer

Object oriented C  can be done  I ve seen that type of code in production in Korea  and it was the most horrible monster I d seen in years  this was like last year 2007  that I saw the code   So yes it can be done  and yes people have done it before  and still do it even in this day and age  But I d recommend C   or Objective-C  both are languages born from C  with the purpose of providing object orientation with different paradigms

User · Answer

If you are convinced that an OOP approach is superior for the problem you are trying to solve  why would you be trying to solve it with a non-OOP language  It seems like you re using the wrong tool for the job  Use C   or some other object-oriented C variant language   If you are asking because you are starting to code on an already existing large project written in C  then you shouldn t try to force your own  or anyone else s  OOP paradigms into the project s infrastructure  Follow the guidelines that are already present in the project  In general  clean APIs and isolated libraries and modules will go a long way towards having a clean OOP-ish design   If  after all this  you really are set on doing OOP C  read this  PDF

User · Answer

Of course  it just won t be as pretty as using a language with built-in support  I ve even written  object-oriented assembler

User · Answer

You can fake it using function pointers  and in fact  I think it is theoretically possible to compile C   programs into C   However  it rarely makes sense to force a paradigm on a language rather than to pick a language that uses a paradigm

User · Answer

The answer to the question is  Yes  you can    Object-oriented C  OOC  kit is for those who want to program in an object-oriented manner  but sticks on the good old C as well  OOC implements classes  single and multiple inheritance  exception handling   Features      Uses only C macros and functions  no language extensions required   ANSI-C       Easy-to-read source code for your application  Care was taken to make things as simple as possible       Single inheritance of classes      Multiple inheritance by interfaces and mixins  since version 1 3       Implementing exceptions  in pure C        Virtual functions for classes      External tool for easy class implementation  For more details  visit http   ooc-coding sourceforge net

User · Answer

One thing you might want to do is look into the implementation of the Xt toolkit for X Window  Sure it is getting long in the tooth  but many of the structures used were designed to work in an OO fashion within traditional C  Generally this means adding an extra layer of indirection here and there and designing structures to lay over each other   You can really do lots in the way of OO situated in C this way  even though it feels like it some times  OO concepts did not spring fully formed from the mind of  include lt favorite OO Guru h gt   They really constituted many of the established best practice of the time  OO languages and systems only distilled and amplified parts of the programing zeitgeist of the day

User · Answer

You may find it helpful to look at Apple s documentation for its Core Foundation set of APIs  It is a pure C API  but many of the types are bridged to Objective-C object equivalents   You may also find it helpful to look at the design of Objective-C itself  It s a bit different from C   in that the object system is defined in terms of C functions  e g  objc msg send to call a method on an object  The compiler translates the square bracket syntax into those function calls  so you don t have to know it  but considering your question you may find it useful to learn how it works under the hood

User · Answer

You may find it helpful to look at Apple s documentation for its Core Foundation set of APIs  It is a pure C API  but many of the types are bridged to Objective-C object equivalents   You may also find it helpful to look at the design of Objective-C itself  It s a bit different from C   in that the object system is defined in terms of C functions  e g  objc msg send to call a method on an object  The compiler translates the square bracket syntax into those function calls  so you don t have to know it  but considering your question you may find it useful to learn how it works under the hood

User · Answer

Object oriented C  can be done  I ve seen that type of code in production in Korea  and it was the most horrible monster I d seen in years  this was like last year 2007  that I saw the code   So yes it can be done  and yes people have done it before  and still do it even in this day and age  But I d recommend C   or Objective-C  both are languages born from C  with the purpose of providing object orientation with different paradigms

User · Answer

A little OOC code to add    include  lt stdio h gt   struct Node       int somevar      void print         printf  Hello from an object-oriented C method         struct Tree       struct Node   NIL      void   FPprint  void       struct Node  root      struct Node NIL t    TreeA     amp TreeA NIL t print    int main         struct Tree TreeB      TreeB   TreeA      TreeB FPprint        return 0

User · Answer

This has been interesting to read  I have been pondering the same question myself  and the benefits of thinking about it are this    Trying to imagine how to implement OOP concepts in a non-OOP language helps me understand the strengths of the OOp language  in my case  C     This helps give me better judgement about whether to use C or C   for a given type of application -- where the benefits of one out-weighs the other  In my browsing the web for information and opinions on this I found an author who was writing code for an embedded processor and only had a C compiler available  http   www eetimes com discussion other 4024626 Object-Oriented-C-Creating-Foundation-Classes-Part-1   In his case  analyzing and adapting OOP concepts in plain C was a valid pursuit  It appears he was open to sacrificing some OOP concepts due to the performance overhead hit resulting from attempting to implement them in C   The lesson I ve taken is  yes it can be done to a certain degree  and yes  there are some good reasons to attempt it   In the end  the machine is twiddling stack pointer bits  making the program counter jump around and calculating memory access operations   From the efficiency standpoint  the fewer of these calculations done by your program  the better    but sometimes we have to pay this tax simply so we can organize our program in a way that makes it least susceptible to human error  The OOP language compiler strives to optimize both aspects  The programmer has to be much more careful implementing these concepts in a language like C

User · Answer

Yes  but I have never seen anyone attempt to implement any sort of polymorphism with C

User · Answer

You can fake it using function pointers  and in fact  I think it is theoretically possible to compile C   programs into C   However  it rarely makes sense to force a paradigm on a language rather than to pick a language that uses a paradigm

User · Answer

One thing you might want to do is look into the implementation of the Xt toolkit for X Window  Sure it is getting long in the tooth  but many of the structures used were designed to work in an OO fashion within traditional C  Generally this means adding an extra layer of indirection here and there and designing structures to lay over each other   You can really do lots in the way of OO situated in C this way  even though it feels like it some times  OO concepts did not spring fully formed from the mind of  include lt favorite OO Guru h gt   They really constituted many of the established best practice of the time  OO languages and systems only distilled and amplified parts of the programing zeitgeist of the day

User · Answer

It s seem like people are trying emulate the C   style using C  My take is that doing object-oriented programming C is really doing struct-oriented programming  However  you can achieve things like late binding  encapsulation  and inheritance  For inheritance you explicitly define a pointer to the base structs in your sub struct and this is obviously a form of multiple inheritance  You ll also need to determine if your    private class h struct private class  extern struct private class   new private class    extern int ret a value struct private class    int a  int b   extern void delete private class struct private class     void   late bind function  struct private class  p      private class c struct inherited class 1  struct inherited class 2   struct private class     int a    int b    struct inherited class 1  p1    struct inherited class 2  p2      struct inherited class 1   new inherited class 1    struct inherited class 2   new inherited class 2     struct private class   new private class       struct private class  p    p    struct private class   malloc sizeof struct private class      p- gt a   0    p- gt b   0    p- gt p1   new inherited class 1      p- gt p2   new inherited class 2      return p         int ret a value struct private class  p  int a  int b          return p- gt a   p- gt b   a   b             void delete private class struct private class  p            release any resources         call delete methods for inherited classes       free p               main c     struct private class  p      p   new private class        late bind function    amp implementation function      delete private class p     compile with c compiler main c inherited class 1 obj inherited class 2 obj  private class obj   So the advice is to stick to a pure C style and not try to force into a C   style  Also this way lends itself to a very clean way of building an API

User · Answer

Since you re talking about polymorphism then yes  you can  we were doing that sort of stuff years before C   came about   Basically you use a struct to hold both the data and a list of function pointers to point to the relevant functions for that data   So  in a communications class  you would have an open  read  write and close call which would be maintained as four function pointers in the structure  alongside the data for an object  something like   typedef struct       int   open  void  self  char  fspec       int   close  void  self       int   read  void  self  void  buff  size t max sz  size t  p act sz       int   write  void  self  void  buff  size t max sz  size t  p act sz          And data goes here    tCommClass   tCommClass commRs232  commRs232 open    amp rs232Open      commRs232 write    amp rs232Write   tCommClass commTcp  commTcp open    amp tcpOpen      commTcp write    amp tcpWrite    Of course  those code segments above would actually be in a  constructor  such as rs232Init     When you  inherit  from that class  you just change the pointers to point to your own functions  Everyone that called those functions would do it through the function pointers  giving you your polymorphism   int stat    commTcp open  commTcp   bigiron box com 5000      Sort of like a manual vtable   You could even have virtual classes by setting the pointers to NULL -the behaviour would be slightly different to C    a core dump at run-time rather than an error at compile time    Here s a piece of sample code that demonstrates it  First the top-level class structure    include  lt stdio h gt      The top-level class   typedef struct sCommClass       int   open  struct sCommClass  self  char  fspec     tCommClass    Then we have the functions for the TCP  subclass       Function for the TCP  class    static int tcpOpen  tCommClass  tcp  char  fspec        printf   Opening TCP   s n   fspec       return 0    static int tcpInit  tCommClass  tcp        tcp- gt open    amp tcpOpen      return 0      And the HTTP one as well      Function for the HTTP  class    static int httpOpen  tCommClass  http  char  fspec        printf   Opening HTTP   s n   fspec       return 0    static int httpInit  tCommClass  http        http- gt open    amp httpOpen      return 0      And finally a test program to show it in action      Test program   int main  void        int status      tCommClass commTcp  commHttp          Same  base  class but initialised to different sub-classes       tcpInit   amp commTcp       httpInit   amp commHttp           Called in exactly the same manner       status    commTcp open   amp commTcp   bigiron box com 5000        status    commHttp open   amp commHttp   http   www microsoft com         return 0      This produces the output   Opening TCP  bigiron box com 5000 Opening HTTP  http   www microsoft com   so you can see that the different functions are being called  depending on the sub-class

User · Answer

The C stdio FILE sub-library is an excellent example of how to create abstraction  encapsulation  and modularity in unadulterated C    Inheritance and polymorphism - the other aspects often considered essential to OOP - do not necessarily provide the productivity gains they promise and reasonable arguments have been made that they can actually hinder development and thinking about the problem domain

User · Answer

Trivial example with an Animal and Dog  You mirror C   s vtable mechanism  largely anyway   You also separate allocation and instantiation  Animal Alloc  Animal New  so we don t call malloc   multiple times  We must also explicitly pass the this pointer around   If you were to do non-virtual functions  that s trival  You just don t add them to the vtable and static functions don t require a this pointer  Multiple inheritance generally requires multiple vtables to resolve ambiguities   Also  you should be able to use setjmp longjmp to do exception handling   struct Animal Vtable      typedef void   Walk Fun  struct Animal  a This       typedef struct Animal     Dtor Fun  struct Animal  a This        Walk Fun Walk      Dtor Fun Dtor      struct Animal      Animal Vtable vtable       char  Name      struct Dog      Animal Vtable vtable       char  Name     Mirror member variables for easy access     char  Type      void Animal Walk struct Animal  a This       printf  Animal   s  walking n   a This- gt Name      struct Animal  Animal Dtor struct Animal  a This       printf  animal  dtor n        return a This     Animal  Animal Alloc        return  Animal  malloc sizeof Animal       Animal  Animal New Animal  a Animal       a Animal- gt vtable Walk   Animal Walk      a Animal- gt vtable Dtor   Animal Dtor      a Animal- gt Name    Anonymous       return a Animal     void Animal Free Animal  a This       a This- gt vtable Dtor a This        free a This      void Dog Walk struct Dog  a This       printf  Dog walking  s   s  n   a This- gt Type  a This- gt Name      Dog  Dog Dtor struct Dog  a This          Explicit call to parent destructor     Animal Dtor  Animal  a This        printf  dog  dtor n         return a This     Dog  Dog Alloc        return  Dog  malloc sizeof Dog       Dog  Dog New Dog  a Dog          Explict call to parent constructor     Animal New  Animal  a Dog        a Dog- gt Type    Dog type       a Dog- gt vtable Walk    Animal Vtable  Walk Fun  Dog Walk      a Dog- gt vtable Dtor    Animal Vtable  Dtor Fun  Dog Dtor       return a Dog     int main int argc  char   argv                Base class           Animal  a Animal   Animal New Animal Alloc                Animal  a Animal    Animal  Dog New Dog Alloc          a Animal- gt vtable Walk a Animal        Animal Free a Animal       PS  This is tested on a C   compiler  but it should be easy to make it work on a C compiler

User · Answer

Yes  it is possible   This is pure C  no macros preprocessing  It has inheritance  polymorphism  data encapsulation  including private data   It does not have equivalent protected qualifier  wich means private data is private down the inheritance chain too    include  triangle h   include  rectangle h   include  polygon h    include  lt stdio h gt   int main         Triangle tr1  CTriangle- gt new        Rectangle rc1  CRectangle- gt new         tr1- gt width  rc1- gt width  3 2      tr1- gt height  rc1- gt height  4 1       CPolygon- gt printArea  Polygon tr1        printf   n         CPolygon- gt printArea  Polygon rc1        output  6 56 13 12

User · Answer

Trivial example with an Animal and Dog  You mirror C   s vtable mechanism  largely anyway   You also separate allocation and instantiation  Animal Alloc  Animal New  so we don t call malloc   multiple times  We must also explicitly pass the this pointer around   If you were to do non-virtual functions  that s trival  You just don t add them to the vtable and static functions don t require a this pointer  Multiple inheritance generally requires multiple vtables to resolve ambiguities   Also  you should be able to use setjmp longjmp to do exception handling   struct Animal Vtable      typedef void   Walk Fun  struct Animal  a This       typedef struct Animal     Dtor Fun  struct Animal  a This        Walk Fun Walk      Dtor Fun Dtor      struct Animal      Animal Vtable vtable       char  Name      struct Dog      Animal Vtable vtable       char  Name     Mirror member variables for easy access     char  Type      void Animal Walk struct Animal  a This       printf  Animal   s  walking n   a This- gt Name      struct Animal  Animal Dtor struct Animal  a This       printf  animal  dtor n        return a This     Animal  Animal Alloc        return  Animal  malloc sizeof Animal       Animal  Animal New Animal  a Animal       a Animal- gt vtable Walk   Animal Walk      a Animal- gt vtable Dtor   Animal Dtor      a Animal- gt Name    Anonymous       return a Animal     void Animal Free Animal  a This       a This- gt vtable Dtor a This        free a This      void Dog Walk struct Dog  a This       printf  Dog walking  s   s  n   a This- gt Type  a This- gt Name      Dog  Dog Dtor struct Dog  a This          Explicit call to parent destructor     Animal Dtor  Animal  a This        printf  dog  dtor n         return a This     Dog  Dog Alloc        return  Dog  malloc sizeof Dog       Dog  Dog New Dog  a Dog          Explict call to parent constructor     Animal New  Animal  a Dog        a Dog- gt Type    Dog type       a Dog- gt vtable Walk    Animal Vtable  Walk Fun  Dog Walk      a Dog- gt vtable Dtor    Animal Vtable  Dtor Fun  Dog Dtor       return a Dog     int main int argc  char   argv                Base class           Animal  a Animal   Animal New Animal Alloc                Animal  a Animal    Animal  Dog New Dog Alloc          a Animal- gt vtable Walk a Animal        Animal Free a Animal       PS  This is tested on a C   compiler  but it should be easy to make it work on a C compiler

User · Answer

You can fake it using function pointers  and in fact  I think it is theoretically possible to compile C   programs into C   However  it rarely makes sense to force a paradigm on a language rather than to pick a language that uses a paradigm

User · Answer

Yes  you can  People were writing object-oriented C before C   or Objective-C came on the scene  Both C   and Objective-C were  in parts  attempts to take some of the OO concepts used in C and formalize them as part of the language   Here s a really simple program that shows how you can make something that looks-like is a method call  there are better ways to do this  This is just proof the language supports the concepts     include lt stdio h gt   struct foobarbaz      int one      int two      int three      int   exampleMethod  int  int       int addTwoNumbers int a  int b       return a b     int main            Define the function pointer     int   pointerToFunction  int  int    addTwoNumbers          Let s make sure we can call the pointer     int test     pointerToFunction  12 12       printf   test   u  n    test           Now  define an instance of our struct        and add some default values      struct foobarbaz fbb      fbb one     1      fbb two     2      fbb three   3          Now add a  method      fbb exampleMethod   addTwoNumbers          Try calling the method     int test2   fbb exampleMethod 13 36       printf   test2   u  n    test2        printf   nDone n        return 0

User · Answer

Namespaces are often done by doing   stack push thing      instead of  stack  push thing      To make a C struct into something like a C   class you can turn   class stack        public          stack            void push thing             thing   pop            static int this is here as an example only       private                   Into  struct stack        struct stack type   my type          Put the stuff that you put after private  here    struct stack type        void    construct  struct stack   this      This takes uninitialized memory      struct stack      operator new        This allocates a new struct  passes it to construct  and then returns it      void   push  struct stack   this  thing   t      Pushing t onto this stack      thing     pop  struct stack   this      Pops the top thing off the stack and returns it      int this is here as an example only   Stack          construct   stack construct       operator new   stack operator new       push   stack push       pop   stack pop       All of these functions are assumed to be defined somewhere else   And do   struct stack   st   Stack operator new       Make a new stack if   st          Do something about it   else         You can use the stack    stack push st  thing0      This is a non-virtual call    Stack push st  thing1      This is like casting  st to a Stack  which it already is  and doing the push    st- gt my type push st  thing2      This is a virtual call     I didn t do the destructor or delete  but it follows the same pattern   this is here as an example only is like a static class variable -- shared among all instances of a type  All methods are really static  except that some take a this

User · Answer

There is an example of inheritance using C in Jim Larson s 1996 talk given at the Section 312 Programming Lunchtime Seminar here  High and Low-Level C

User · Answer

Sure that is possible  This is what GObject  the framework that all of GTK  and GNOME is based on  does

User · Answer

Namespaces are often done by doing   stack push thing      instead of  stack  push thing      To make a C struct into something like a C   class you can turn   class stack        public          stack            void push thing             thing   pop            static int this is here as an example only       private                   Into  struct stack        struct stack type   my type          Put the stuff that you put after private  here    struct stack type        void    construct  struct stack   this      This takes uninitialized memory      struct stack      operator new        This allocates a new struct  passes it to construct  and then returns it      void   push  struct stack   this  thing   t      Pushing t onto this stack      thing     pop  struct stack   this      Pops the top thing off the stack and returns it      int this is here as an example only   Stack          construct   stack construct       operator new   stack operator new       push   stack push       pop   stack pop       All of these functions are assumed to be defined somewhere else   And do   struct stack   st   Stack operator new       Make a new stack if   st          Do something about it   else         You can use the stack    stack push st  thing0      This is a non-virtual call    Stack push st  thing1      This is like casting  st to a Stack  which it already is  and doing the push    st- gt my type push st  thing2      This is a virtual call     I didn t do the destructor or delete  but it follows the same pattern   this is here as an example only is like a static class variable -- shared among all instances of a type  All methods are really static  except that some take a this

[c] How would one write object-oriented code in C?

Examples related to c

Examples related to oop

Examples related to object