objects in C

[Michael]

Hello world,
many readers helped me with my struct query,
so I fell encouraged to post another question.
I wonder if linking functions via pointers
to structs is "a good idea". E.g. a stack

struct stack
{
/* some var in here */
void (*push)(<pointer to stack>, <object>);
};
/* ... */
struct stack test;
/* ... */
test.push(&test, <stuff>);

Since there is no "this" pointer in C (at least I
do not know), is there an advantage in using an object-
like structure (not only member-var but also functions
packed together)?
Well, or does it depend on the situation?
Thanks
Michael

 

[Nils Petter Vaskinn]

Hello world,
many readers helped me with my struct query,
so I fell encouraged to post another question.
I wonder if linking functions via pointers
to structs is "a good idea". E.g. a stack

struct stack
{
/* some var in here */
void (*push)(<pointer to stack>, <object>);
};
/* ... */
struct stack test;

push = pointer_to_push_function;

And you have to remember to to that each and every time you make a
stack, for every function. Kinds of kills the benefit.

/* ... */
test.push(&test, <stuff>);

Since there is no "this" pointer in C (at least I
do not know), is there an advantage in using an object-
like structure (not only member-var but also functions
packed together)?
Well, or does it depend on the situation?

Yes there are advantages. C++ was created for when you need those and are
willing to pay the price. If you're a little structured (no pun intended)
you can do without having the function as part of the struct (unless you
are going to do something strange like change the push function at
runtime) and save having all those pointers in your structs.

#include <stdio.h>

struct stack
{
int *blah;
};

int stack_push(struct stack*,int);
int stack_pop(struct stack*,int*);
int stack_count(struct stack*,int*);

/* implementation here */

int main(void) {
struct stack test;
int value;

if (stack_push(&test,42)) {
/* successfully pushed onto stack */
} else {
/* error handling */
}

/* do stufF */

if (stack_pop(&test,&value)) {
/* successfully popped stack */
} else {
/* failed, perhaps the stack was empty */
/* error handling */
}
return 0;
}

 

[AJ Mohan Rao]

Hello world,
many readers helped me with my struct query,
so I fell encouraged to post another question.
I wonder if linking functions via pointers
to structs is "a good idea". E.g. a stack

It is not uncommon to use this way.

struct stack
{
/* some var in here */
void (*push)(<pointer to stack>, <object>);
};
/* ... */
struct stack test;
/* ... */
test.push(&test, <stuff>);

Since there is no "this" pointer in C (at least I
do not know), is there an advantage in using an object-
like structure (not only member-var but also functions
packed together)?
Well, or does it depend on the situation?

thats how we implement virtual functions in C.
It is advantageous in some situations.

 

[pete]

Hello world,
many readers helped me with my struct query,
so I fell encouraged to post another question.
I wonder if linking functions via pointers
to structs is "a good idea". E.g. a stack

struct stack
{
/* some var in here */
void (*push)(<pointer to stack>, <object>);
};
/* ... */
struct stack test;
/* ... */
test.push(&test, <stuff>);

Since there is no "this" pointer in C (at least I
do not know), is there an advantage in using an object-
like structure (not only member-var but also functions
packed together)?
Well, or does it depend on the situation?

I use arrays of structures with function pointers,
to race sorting functions against each other,
with various array distributions.

struct sf {
void(*sortfunc)(e_type *, size_t);
char *name;
char *description;
double total_time;
};

struct sf s_L[] = SORT_LIST;
struct df {
void(*distfunc)(e_type *, size_t);
char *string;
} d_L[] = DISTRIBUTION_LIST;

 

[Fred L. Kleinschmidt]

Hello world,
many readers helped me with my struct query,
so I fell encouraged to post another question.
I wonder if linking functions via pointers
to structs is "a good idea". E.g. a stack

struct stack
{
/* some var in here */
void (*push)(<pointer to stack>, <object>);
};
/* ... */
struct stack test;
/* ... */
test.push(&test, <stuff>);

Since there is no "this" pointer in C (at least I
do not know), is there an advantage in using an object-
like structure (not only member-var but also functions
packed together)?
Well, or does it depend on the situation?
Thanks
Michael

This is essentially how Motif works, with one major exception: you
define two structs; one has only one (global) instance, and the other
has a pointer to that global instance.
For example (much simplified):
/* First, declare function typoes */
typedef void (*MyProcA)( int n, char *s );
typedef int (*MyProcB)( double d );

/* Provide prototypes for your functions */
void ProcA( int n, char *s);
int ProcB( double d);

/* Define the class struct, and an instance of it */
typedef struct _ClassRec {
MyProcA ProcA;
MyProcB ProcB;
}ClassRec;
ClassRec classRec;

/* Define instance struct */
typedef struct _InstanceRec {
ClassRec *class_rec_ptr;
/* plus any instance variables */
...
}InstanceRec;


Then define your code - instances of InstanceRec, functions ProcA and
ProcB, etc.

This creates a pseudo-object-oriented paradigm from the
non-object-oriented C language, in that when you create instances of
struct InstanceRec, your code can access the functions defined in
ClassRec.

 

[Bruno Desthuilliers]

push = pointer_to_push_function;

And you have to remember to to that each and every time you make a
stack, for every function. Kinds of kills the benefit.

Well, as anyone writing such code will also create an init() function,
this is not really a problem.

Yes there are advantages. C++ was created for when you need those and are
willing to pay the price. If you're a little structured (no pun intended)
you can do without having the function as part of the struct (unless you
are going to do something strange like change the push function at
runtime) and save having all those pointers in your structs.

Right, but the function-ptr-in-the-struct option let you have some kind
of polymorphism, that you can't have (in C) with the classical-ADT option.

Now it's also clear that when you come to this, it's time to consider
using another language (if possible !-)

Bruno

 

[SenderX]

Since there is no "this" pointer in C (at least I

do not know), is there an advantage in using an object-
like structure (not only member-var but also functions
packed together)?
Well, or does it depend on the situation?

You could do something like this:


/* Stack interface */
typedef struct IStack_
{

void ( *fpPush ) ( struct IStack_ *pStack, const void *pUserState );

void* ( *fpPop ) ( struct IStack_ *pStack );

void* ( *fpFree ) ( struct IStack_ *pStack );

void *pImpl;

} *IStack;


/* Stack API */
#define StackPush( i, us ) ( (i)->fpPush( (i), (us) ) )
#define StackPop( i ) ( (i)->fpPop( (i) ) )
#define StackFree( i ) ( (i)->fpFree( (i) ) )


Then you could easily create different types of stacks that share a single
interface.

OOP in C can be easy and flexible...

 

[Rob Thorpe]

Hello world,
many readers helped me with my struct query,
so I fell encouraged to post another question.
I wonder if linking functions via pointers
to structs is "a good idea". E.g. a stack

struct stack
{
/* some var in here */
void (*push)(<pointer to stack>, <object>);
};
/* ... */
struct stack test;
/* ... */
test.push(&test, <stuff>);

Since there is no "this" pointer in C (at least I
do not know), is there an advantage in using an object-
like structure (not only member-var but also functions
packed together)?
Well, or does it depend on the situation?
Thanks
Michael

You can do this, and as other posters have pointed out there are other
ways to do it that can make things a little easier.

If you can avoid this programming style, it often becomes confusing if
your not very careful.

Define the struct in a .h file, put the functions that act upon it in
the corresponding .c file.

Only think about putting function pointers in the struct if you might
change what they point to somewhere in the program. So in your
example it is not a good idea to do so with push and pop.

 

[Michael]

Hi,
thanks to all of you, I guess
I am going to avoid function-pointers.
Michael

 

[SenderX]

thanks to all of you, I guess

I am going to avoid function-pointers.

I would not rule out using function-pointers. They are a great tool that
makes generic programming in C a piece of cake.

 

[Nils Petter Vaskinn]

Hi,
thanks to all of you, I guess
I am going to avoid function-pointers.

Don't. Just avoid them when you don't need them, or there are better ways
to achieve what you want. Function pointers can be poverful it just that
using them like that might mean you should reconsider either your design
or your choice of implementation language.

Now we never asked what the purpose of your program was. If it was simply
a toy, to learn about function pointers and experiment with object
orientation in C, you should go ahead and do it your way anyway.
If you wanted to do this to learn you could even do several
paralell versions, using different techniques.