OOP in C!

[Prashanth Ellina]

Hi,

I have a feeling that OOP can be done in C also. I have used a
structure to hold member variables and function pointers. The
structure is used as a class to create new 'objects'. But I hit a
problem. How do I access these 'member variables' from the function
that is pointed to by the function pointer in the structure.

I would really appreciate help with this and a code sample will be
wonderful.

Thanks in advance,
Prashanth Ellina

[Rufus V. Smith]

"Malcolm" <ma*****@55bank .freeserve.co.u k> wrote in message
news:ca******** **@newsg2.svr.p ol.co.uk...

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote

I merely asked for an example of a function pointer
that is not used as a callback function.
So far, you have failed to provide one.
OK here's an example.

/*
return the maximum value of an stdlib maths function that takes one

scalar as its argument.
*/
double maximum( double (*fptr)(double x) )
{
if( fptr == sin)
return 1.0;
if(fptr == sqrt)
return DBL_MAX;
if(fptr == asin)
return 3.14 * 2.0;

/* add extra for the other function in the maths library */
}

Good One Malcolm!

Almost made me wet my pants.

I've been absent from the newsgroups for a time (unemployment can do that),
but was following this thread with some uneasy interest.

At first I thought, "of course function pointers aren't used only for
callback functions." But after reading and thinking, I decided that
ultimately,
if that function pointer is every actually used it is effectively "calling
back" to
the function it points to.

However, your fine example shows that if we use the function pointers only
as pointers, there is no "calling", hence no "callback" happening.

Which brings me back to one observation, though:

function pointers are NEVER callback functions

They are POINTERS TO callback functions.

let me slip back into my teapot now.

Rufus

[Grumble]

E. Robert Tisdale wrote:

Arthur J. O'Dwyer wrote:

These are functions, but they are not callback functions.

That's a lie.

Not every function is a callback function.
Some programs do not use callback functions at all.

I never said different.

Stephen's program appears to be one of them.

Stephen Sprunk's does, in fact, use callback functions.
It is a classical example of the use of callback functions.

You have never provided a single reason
why you believe that these are not callback functions.
I submit that the reason is that you can't
and that you know that you can't.
You are simply trolling.

Please go away troll.

Bob,

(Can I call you Bob?)

You sound like a 12-year old.

Why don't you take a break from Usenet, and come back next year.

[Richard Tobin]

In article <ca**********@n ntp1.jpl.nasa.g ov>,
E. Robert Tisdale <E.************ **@jpl.nasa.gov > wrote:

It's not usually used for the case
where a library gives you a function to call.

I never argued that the callback function was provided by the library.

Surely in the method case the object is analogous to the library. The
object provides a function pointer for you to call.

To regard this as a callback means considering "you" to be the object,
and the program using the object to be in the role of the library,
which is the wrong way round.

-- Richard

[E. Robert Tisdale]

Richard Tobin wrote:

E. Robert Tisdale wrote:

It's not usually used for the case
where a library gives you a function to call.
I never argued that the callback function was provided by the library.

Surely, in the method case,

I'm not sure what you mean by "method case".
the object is analogous to the library.
No.
You might draw that analogy for an object of the *base* type
but *not* for an object of a type *derived* from the base type
by you -- the user of the base class (library).
The object provides a function pointer for you to call.

To regard this as a callback means considering "you" to be the object,
Well, it means the *you* provided the object which contains a pointer
to the callback function or to a table which contains pointers
to callback functions.
and the program using the object to be in the role of the library,
which is the wrong way round.

I think that you are confused.
Try giving us an example.

[Michael Wojcik]

In article <ec************ *************** ***@news.terane ws.com>, "Rufus V. Smith" <no****@nospam. com> writes:

At first I thought, "of course function pointers aren't used only for
callback functions." But after reading and thinking, I decided that
ultimately, if that function pointer is every actually used it is
effectively "calling back" to the function it points to.

When function pointers are used to implement a jump table, in what sense
are calls through them "back" to the functions they point to?

For example:

----- snip -----
#include <stdio.h>

void foo(void) { puts("foo"); }
void bar(void) { puts("bar"); }

void (*fptrs[])(void) = {foo, bar};

int main(void)
{
int c, i;

while ((c = getchar()) != EOF) {
switch (c) {
case 'f': i = 0; break;
case 'b': i = 1; break;
default: i = -1; break;
}
if (i >= 0 && i < sizeof fptrs / sizeof fptrs[0])
fptrs[i]();
}

return 0;
}
----- snip -----

That's obviously a trivial example, but it's no different in principle
than a real program that uses an array of function pointers to perform
various operations based on input. Such programs typically compute an
index into the array, then call the function corresponding to that
index. It's equivalent to having a switch for each possible index
value and an explicit call to the corresponding function, but tidier.

When foo or bar is called, in what sense is that call "back" to
something? "Back" from where?

A function F acts as a callback when it belongs to domain A, domain A
makes F available to domain B, domain A calls into domain B, and
domain B calls F. Callback is a role that a function can satisfy. It
has nothing to do with function pointers whatsoever.

--
Michael Wojcik mi************@ microfocus.com

Duck: No secret what's worth a hoot ought to be kept quiet.
Pogo: Secrets is usually perty doggone fascinatin'.
Duck: Egg-zackly ... it's completely illogical to keep a secret secret.
Pogo: An' unfair. -- Walt Kelly

[Mike Wahler]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote in message
news:ca******** **@nntp1.jpl.na sa.gov...

Something that calls itself Christian Bau wrote:

A function pointer is by definition a callback function.

You are a liar.
I never said any such thing.
I merely asked for an example of a function pointer
that is not used as a callback function.
So far, you have failed to provide one.

Here's a crumb for the troll:

void (*fp)(void); /* not used as a callback function */

Also note that no function pointer can be used as a
callback function, since a pointer is not a function,
nor is it convertible to one.
-Mike

[Mike Wahler]

"Prashanth Ellina" <pr************ *@hotpop.com> wrote in message
news:28******** *************** ***@posting.goo gle.com...

"Mike Wahler" <mk******@mkwah ler.net> wrote in message news:<VN******* ***********@new sread1.news.pas .earthlink.net> ...

#include <stdio.h>

struct S
{
int member;
void (*fp)(struct S *);
};

void func(struct S *param)
{
printf("%d\n", param->member);
}

int main()
{
struct S object = {42, func};
func(&object); /* prints 42 */

shouldn't the above line be,
object.fp(&obje ct);
?

Yes, to do it "OO style". Sorry about the typo.
However, the original form is still valid code
(defeating the purpose of the example,
but causing me to take a clean compile as
'what I meant'. :-)).
-Mike

[E. Robert Tisdale]

Michael Wojcik wrote:

Rufus V. Smith writes:

At first I thought, "of course function pointers aren't used only for
callback functions." But after reading and thinking, I decided that
ultimately, if that function pointer is every actually used
it is effectively "calling back" to the function it points to.
When function pointers are used to implement a jump table,
in what sense are calls through them
"back" to the functions they point to?

For example:

----- snip -----
#include <stdio.h>

// domain A: void foo(void) { puts("foo"); }
void bar(void) { puts("bar"); }

void (*fptrs[])(void) = {foo, bar};
// domain B: int main(int argc, char* argv[]) {
int c = EOF;

while ((c = getchar()) != EOF) {
int i = -1;
switch (c) {
case 'f': i = 0; break;
case 'b': i = 1; break;
default: i = -1; break;
}
if (0 <= i && i < sizeof fptrs/sizeof fptrs[0])
fptrs[i]();
}

return 0;
}
----- snip ----- That's obviously a trivial example,
but it's no different in principle
than a real program that uses an array of function pointers
to perform various operations based on input.
Except that is lacks any motivation for doing so
besides to help you make your point.
Such programs typically compute an index into the array,
then call the function corresponding to that index.
It's equivalent to having a switch for each possible index value
and an explicit call to the corresponding function, but tidier. When foo or bar is called,
in what sense is that call "back" to something? "Back" from where? A function F acts as a callback
when it belongs to domain A, domain A makes F available to domain B,
domain A calls into domain B, and domain B calls F.
The problem with your example is that main(void) is a function
that could be viewed an domain B.
You could "disambigua te" this by moving

void (*fptrs[])(void) = {foo, bar};

inside the definition of function main(void).

Callback is a role that a function can satisfy.
It has nothing to do with function pointers whatsoever.

Correct.
In this example:

#include <stdio.h>

void f(const void (*fptrs[])(void)) { // domain B
int c = EOF;

while ((c = getchar()) != EOF) {
int i = -1;
switch (c) {
case 'f': i = 0; break;
case 'b': i = +1; break;
default: i = -1; break;
}
if (0 <= i && i < sizeof fptrs/sizeof fptrs[0])
fptrs[i]();
}
}

void foo(void) { puts("foo"); }
void bar(void) { puts("bar"); }

int main(int argc, char* argv[]) { // domain A
const
void (*fptrs[])(void) = {foo, bar};
f(fptrs);
return 0;
}

foo(void) and bar(void) *are* callback functions
called back from function f(const void (*fptrs[])(void))
through the fptrs "jump table"
supplied by function main(int, char**).

[Michael Wojcik]

In article <ca**********@n ntp1.jpl.nasa.g ov>, "E. Robert Tisdale" <E.************ **@jpl.nasa.gov > writes:

Michael Wojcik wrote:

That's obviously a trivial example,
but it's no different in principle
than a real program that uses an array of function pointers
to perform various operations based on input.
Except that is lacks any motivation for doing so
besides to help you make your point.

A fascinating observation. What part of the word "example" do you
not understand?

Or are you claiming that there are no real, nontrivial programs
which use this mechanism? If so, kindly prove it.

A function F acts as a callback
when it belongs to domain A, domain A makes F available to domain B,
domain A calls into domain B, and domain B calls F.

The problem with your example is that main(void) is a function
that could be viewed an domain B.

No it can't, since in my example nothing calls main except the
environment. The environment is not part of the program. Thus
there is no domain A in the program which can invoke main; thus
main cannot be domain B.
You could "disambigua te" this by moving

void (*fptrs[])(void) = {foo, bar};

inside the definition of function main(void).

This changes nothing. foo and bar are still not callbacks,
because they are not called "back" into anywhere. They are
called "forward", just as if they were called directly rather
than through a function pointer.

The jump table example is precisely an example of using a
function pointer for a "forward" call.

--
Michael Wojcik mi************@ microfocus.com

Proverbs for Paranoids, 2: The innocence of the creatures is in inverse
proportion to the immorality of the Master. -- Thomas Pynchon

[SenderX]

I would really appreciate help with this and a code sample will be
wonderful.

http://groups.google.com/groups?selm...tbi_s02&rnum=4

There ya go.