Casting void * to void ** ?

[Twister]

Hi All,

I have a question which might sound very basic.

I have a simple structure:

struct simple{
void *buffer;
};
typedef struct simple Simple;

In my function I do this:

void do_Something(){

Simple *simp_struct;
simp_struct->buffer = malloc(10 * sizeof(int *));

call_func((void **)((int **)(simp_struct->buffer)));
....
}

The function call_func has this prototype:
call_func(void **buf);

I am confused with this piece of code:
call_func((void **)((int **)(simp_struct->buffer)));

What does this construct mean? How is that simp_struct->buffer
(which is a void *) is being cast to a int** followed by a
cast to void ** and passed to call_func ?

Rgds.
Mirage

[Joe Smith]

"Richard Heathfield"

Joe Smith said:

"Richard Heathfield"

I'm not sure why you'd need memory techniques for Euclid's Algorithm.
The reason, for better or worse, that I think I need a memory technique
might have to do with the development as given by Gallian. We had the
division algorithm that would be guaranteed to terminate in a finite number
of steps, and then we had to rewrite all the equations and substitute, so as
to write a given N as a linear combo. I'm failing to see how this stack of
numbers behaves in your treatment. With a debugger that is only telling me
'no matching symbolic information found', I am unable to step through.
You can find an implementation on p326 of CU. Alternatively, here's my
own,
relatively straightforward , implementation of Knuth's description of
Euclid's Algorithm in TAOCP:

You and Knuth solved this using recursion, where the computer worries
about providing for its own memory.

Actually, I did but Knuth didn't. Here is an even more straightforward
implementation of Knuth's description of Euclid's Algorithm in TAOCP,
without using recursion:

unsigned long gcd(unsigned long m, unsigned long n)
{
if(m < n)
{
unsigned long temp = m;
m = n;
n = temp;
}
if(n > 0)
{
unsigned long r;
do
{
r = m % n;
m = n;
n = r ? r : n;
} while(r > 0);
}

return n;
}

I guess what I'll do is add some printf's and breaks and do some figgerin.
Joe

[Joe Smith]

"Richard Heathfield" <in*****@invali d.invalid> wrote in message
news:ie******** ************@bt .com...

Joe Smith said:

"Richard Heathfield"

I'm not sure why you'd need memory techniques for Euclid's Algorithm.

You can find an implementation on p326 of CU. Alternatively, here's my
own,
relatively straightforward , implementation of Knuth's description of
Euclid's Algorithm in TAOCP:

You and Knuth solved this using recursion, where the computer worries
about providing for its own memory.

Actually, I did but Knuth didn't. Here is an even more straightforward
implementation of Knuth's description of Euclid's Algorithm in TAOCP,
without using recursion:

unsigned long gcd(unsigned long m, unsigned long n)
{
if(m < n)
{
unsigned long temp = m;
m = n;
n = temp;
}
if(n > 0)
{
unsigned long r;
do
{
r = m % n;
m = n;
n = r ? r : n;
} while(r > 0);
}

return n;
}

Bear with me, please. Elsethread:
news:44******** **************@ news.usenetmons ter.com...
I've elaborated on this theme and seek comment. I have a debugger now, so
my programming IQ just got a bump. Joe