Very Computer

Does anyone have an Idea as to how to implement object oriented design
in language C ?

Although this may lead to a little loss of performance in terms of
coding and execution but I have seen many of the c++ compilers generate
the c code from c++ code and then compile it.

Is there any standard for this. If yes what is it ?

Sent via Deja.com http://www.deja.com/
Before you buy.

Quote:> Does anyone have an Idea as to how to implement object oriented design
> in language C ?

> Although this may lead to a little loss of performance in terms of
> coding and execution but I have seen many of the c++ compilers generate
> the c code from c++ code and then compile it.

> Is there any standard for this. If yes what is it ?

> Sent via Deja.com http://www.deja.com/
> Before you buy.

I don't think you'll find any performance loss at all, what you will find is
that the coding is a lot more difficult because you have to remember to
adopt a certain style and do things manually that C++ would do
automatically. Among the difficulties I can think of are

a) It's not possible to overide the assignment operator, you'll have to
define a function and remember to use it instead of =.

b) It's not possible to define a destructor, you'll have to define a
function and remeber to call it every time variable goes out of scope.

c) It's not possible to define a constructor, you'll have to define a
function and remeber to call it when a you declare a variable.

d) It's not possible to define a copy constructor, you'll have to define a
function and remeber to call it when a you initialise of variable with
another. This includes when you pass an object as function parameter.

e) It's not possible to do inheritance cleanly, you'll have to declare the
base class inside the derived class, and handle the pointer casting
yourself.

f) There no way of decaring data members private, you'll just have to
remember not to use them.

g) It not possible do to exceptions in C. You can do the non local transfer
of control with setjmp/longjmp but stack unwinding is impossible.

I'm sure there are other difficulties too. Basically you're going to have to
adopt an extremely restricted programming style (for instance, allocate all
objects on the heap and pass them around as pointers, this gets round
objections a, b, c and d) or you going to have to do a lot of fiddly
programming which will be prone to bugs.

john

Quote:> Does anyone have an Idea as to how to implement object oriented design
> in language C ?

> Although this may lead to a little loss of performance in terms of
> coding and execution but I have seen many of the c++ compilers generate
> the c code from c++ code and then compile it.

> Is there any standard for this. If yes what is it ?

> Sent via Deja.com http://www.deja.com/
> Before you buy.

I don't think you'll find any performance loss at all, what you will find is
that the coding is a lot more difficult because you have to remember to
adopt a certain style and do things manually that C++ would do
automatically. Among the difficulties I can think of are

a) It's not possible to overide the assignment operator, you'll have to
define a function and remember to use it instead of =.

b) It's not possible to define a destructor, you'll have to define a
function and remeber to call it every time variable goes out of scope.

c) It's not possible to define a constructor, you'll have to define a
function and remeber to call it when a you declare a variable.

d) It's not possible to define a copy constructor, you'll have to define a
function and remeber to call it when a you initialise of variable with
another. This includes when you pass an object as function parameter.

e) It's not possible to do inheritance cleanly, you'll have to declare the
base class inside the derived class, and handle the pointer casting
yourself.

f) There no way of decaring data members private, you'll just have to
remember not to use them.

g) It not possible do to exceptions in C. You can do the non local transfer
of control with setjmp/longjmp but stack unwinding is impossible.

I'm sure there are other difficulties too. Basically you're going to have to
adopt an extremely restricted programming style (for instance, allocate all
objects on the heap and pass them around as pointers, this gets round
objections a, b, c and d) or you going to have to do a lot of fiddly
programming which will be prone to bugs.

john

Maybe, maybe not.

Quote:>>but I have seen many of the c++ compilers generate
>> the c code from c++ code and then compile it.
>Cfront did it. I'm not aware of any other compilers of this kind.

Comeau C++ does it.

- Greg
--
Comeau Computing, Producers of Comeau C/C++ 4.2.42 (4.2.43 BETA starting)
Try Comeau C++ online at http://www.comeaucomputing.com/tryitout

How does it handle exceptions then?

john

Through a combo of generated code and compiler helper functions.

- Greg
--
Comeau Computing, Producers of Comeau C/C++ 4.2.42 (4.2.43 BETA starting)
Try Comeau C++ online at http://www.comeaucomputing.com/tryitout

Could you give a short example? Its the stack unwinding part I'm interested
in.

I have thought (maybe I'm wrong) that you'd have to walk the stack to
destroy objects when a exception is thrown. I don't see how to do that in C
but I'd be very interested to learn.

john

longjmp *does* unwind the stack.  I would not be surprised to find out that
is how c++ exceptions are done, or at least how they were implimented in
the beggining.

As far as the original question:  Yes is it definentally possible to do OO
programming in C.  Object Oriented-ness is a programmer attribute not
a language attribute.  A language *supports* OO programing to a certain
extent, or not at all.  For examples of OO programming in C look at the
linux kernel.

Depends on the implementation.  In simpler architectures all it does is reload the
stack pointer and other registers that are not volatile across subroutine calls and
jmps to the appropriate location.

In cases where it does have to examine stack frames on it's way back up, it doesn't
do what C++ refers to as stack unwinding in that it doesn't call the C++ destruction
mechanism.  There is no good way to do this by CALLING setjmp/jongjmp.  Yes if you
were looking at the implementation of longjmp's stack unwinding, it probably would
be clear how it could be modified to make work.

Of course, then you're back to implementing one of the trickier parts of the C++
compiler implementation and you might as well let the compiler guys do it.

This is what I ment by "unwinding the stack".  By reloading the stack
pointer you
have "blown away" all the C local variables for all the functions that
happened
between the call to setjmp and longjmp.  Of course if one of those local
variables
was holding a resource like, for instance, a descriptor to a file opened in
one of those
functions.......

Quote:

>In cases where it does have to examine stack frames on it's way back up, it
doesn't
>do what C++ refers to as stack unwinding in that it doesn't call the C++
destruction
>mechanism.

Ok.  My mistake.  I didn't think about the fact that C++ is calling all the
local variable
desctructors.  The only times I have heard of "stack unwinding" in texts,
they have
been talking about the C behavior.

Quote:>I think whatever is possible in C++ is also
>possible in C (although with an awful amount of extra work.)

I think that saying such is a very delicate statement.
For instance, I can get from New York to California via car
or plane, so in that sense, both are able to accomplish
the same thing, but I think we want to stay away from
general statements that cars and planes are similar or can
accomplish the same things even though there are similarities.

- Greg
--
Comeau Computing, Producers of Comeau C/C++ 4.2.42 (4.2.43 BETA starting)
Try Comeau C++ online at http://www.comeaucomputing.com/tryitout

Quote:> Does anyone have an Idea as to how to implement object oriented design
> in language C ?

> Although this may lead to a little loss of performance in terms of
> coding and execution but I have seen many of the c++ compilers
generate
> the c code from c++ code and then compile it.

> Is there any standard for this. If yes what is it ?

I did this extensively in a situation where we had only a C compiler
and tools for an embedded DSP project.  I was programming analysis
tools in Java at the time, and was able to fairly well do certain
aspects of Java-'inspired' OO using a set of macros that mechanized
single linear inheritance.  The code looked something like:

class(FunctionGen)
{
   extends(AbstractFunctionGen);
   chain_delete();  /* 'virtual' destructor */
   float (*getNextVal)(AbstractFunctionGen*); /* member function */
   float someX;
   float someY;

Quote:};

static float getNextVal(AbstractFunctionGen*pSuper)
{
  LI_THIS(); /* extracts hidden pointer to this */
  super.val = this.someX*this.someY;
  this.someX *= 2.0;

Quote:}

CTOR(FunctionGen)
{
   SUPER_CTOR(AbstractFunctionGen);
   override(AbstractFunctionGen,getNextVal);
   this.someX = 0.0;
   this.someY = 0.0;

Quote:}

FuctionGen* a = new(FunctionGen); /* automatically invoked CTOR! */

and so on.  All with naming tricks and macros.  The key is exploiting
the fact that a pointer to a struct is also a pointer to the first
element of the struct to mechanize the principle that a pointer to a
derived class can be used anywhere a pointer to a base class is
expected (the LSP).  There was a lot more to it than the simple example
above.

I'm sure others have done similar things.  I just wanted to be clear on
my experience when I say:

DON'T DO THIS!!  The only advantage is if you absolutely, positively
cannot get a C++ compiler for your target processor.  The end product
using C/OO is slower, takes more dynamic memory, lot's more work, and
is far (far,far,far) less flexible than using C++.  Note that doing OO
yourself in C isn't related to the fact that some C++ compilers output
C.  The closer you try to match C++ (like, mechanizing VTables to avoid
a function pointer in each instance) the work just gets harder and
harder.

DON'T DO IT.

If you have a C++ compiler available, learn C++ and use that instead of
C (that's true beyond pure OO, C++ templates let you have your cake
(organized, layered design) and eat it too (throughput efficient)).

--
/\----|---------|
||  __o_________o_____
||  | Ye Olde Coder  |
||  VVVVVVVVVVVVVVVVVV

Sent via Deja.com http://www.deja.com/
Before you buy.