Pointer to a Pointer to a struct

[Rodrick Brown]

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int
main(void)
{
typedef struct
{
char **test;
}Testing;

Testing **p;
p = malloc(sizeof(Testing));
p[0]->test[0] = malloc(sizeof(Testing));
strncpy(p[0]->test[0],"Hello World",20);
printf("%s\n",p[0]->test[0]);

return EXIT_SUCCESS;
}

Why does the following crash ?
Not sure what i'm missing please advise thanks.
--
Unix Systems Engineer
The City of New York
Dept. of Information Technology
http://www.nyc.gov/doitt
rbrown[(@)]doitt.nyc.gov
http://www.rodrickbrown.com

[Joona I Palaste]

Rodrick Brown <rbrown[@]doitt.nyc.gov> scribbled the following:

#include <stdio.h>
#include <string.h>
#include <stdlib.h> int
main(void)
{
typedef struct
{
char **test;
}Testing; Testing **p;
p = malloc(sizeof(Testing));
p[0]->test[0] = malloc(sizeof(Testing));
You haven't allocated any memory for p[0], let alone for p[0]->test.
strncpy(p[0]->test[0],"Hello World",20);
And anyway, sizeof(Testing) bytes might very well be too little to
store "Hello World".
printf("%s\n",p[0]->test[0]); return EXIT_SUCCESS;
} Why does the following crash ?
Not sure what i'm missing please advise thanks.

I think the fault is that you don't properly understand double
pointers.

--
/-- Joona Palaste (pa*****@cc.helsinki.fi) ------------- Finland --------\
\-------------------------------------------------------- rules! --------/
"The truth is out there, man! Way out there!"
- Professor Ashfield

[Michael Mair]

Joona I Palaste wrote:

Rodrick Brown <rbrown[@]doitt.nyc.gov> scribbled the following:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int
main(void)
{
typedef struct
{
char **test;
}Testing;

Testing **p;
p = malloc(sizeof(Testing));
p[0]->test[0] = malloc(sizeof(Testing));

You haven't allocated any memory for p[0], let alone for p[0]->test.

strncpy(p[0]->test[0],"Hello World",20);

And anyway, sizeof(Testing) bytes might very well be too little to
store "Hello World".

printf("%s\n",p[0]->test[0]);

return EXIT_SUCCESS;
}

Why does the following crash ?
Not sure what i'm missing please advise thanks.

I think the fault is that you don't properly understand double
pointers.

Joona I Palaste means "pointers to pointers" as in ** and not
as in double *. Just to clarify.

Read section 6 of the C FAQ (on arrays and pointers):
http://www.eskimo.com/~scs/C-faq/s6.html

Cheers
Michael

[Mark F. Haigh]

Michael Mair wrote:

Joona I Palaste wrote:

<snip>

I think the fault is that you don't properly understand double
pointers.

Joona I Palaste means "pointers to pointers" as in ** and not
as in double *. Just to clarify.

<snip>

To nitpick, I think Joona meant "double indirection". Not that it
really matters.
Mark F. Haigh
mf*****@sbcglobal.net

[jacob navia]

Joona I Palaste wrote:

Rodrick Brown <rbrown[@]doitt.nyc.gov> scribbled the following:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int
main(void)
{
typedef struct
{
char **test;
}Testing;

Testing **p;
p = malloc(sizeof(Testing));
p[0]->test[0] = malloc(sizeof(Testing));

You haven't allocated any memory for p[0], let alone for p[0]->test.

The "testing" structure contains only one member:
a pointer that points to a pointer to characters.
The size of a pointer is (assumed) 4 (32 bit system).

Then, your structure is just 4 bytes long.

Another thing would be:
typedef struct { char Test[256]; }Testing;

*THEN* you would be able to do your copy
I think the fault is that you don't properly understand double
pointers.

Exactly

[John Bode]

Rodrick Brown <rbrown[@]doitt.nyc.gov> wrote in message news:<2004101503155216807%rbrown@doittnycgov>...

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int
main(void)
{
typedef struct
{
char **test;
}Testing;

Testing **p;
p = malloc(sizeof(Testing));
You have a mismatch here. You're allocating memory for an object of
type Testing, but assigning the resulting pointer to an object of type
pointer to pointer to Testing.

type of p == Testing **, value == return value of malloc()
type of p[0] == Testing *, value == indeterminate
p[0]->test[0] = malloc(sizeof(Testing));
You've missed a step in your allocation -- p points somewhere
meaningful after the first malloc() (even with the mismatch), but p[0]
does not, so you're attempting to dereference an invalid pointer.
This is why you are crashing.
strncpy(p[0]->test[0],"Hello World",20);
Same thing here. You've skipped an allocation step (although you've
already crashed by now anyway; besides, you likely haven't allocated
enough memory to hold the string if you're going by the size of the
struct).
printf("%s\n",p[0]->test[0]);

return EXIT_SUCCESS;
}

Why does the following crash ?
Not sure what i'm missing please advise thanks.

You're doing double indirection, so you have to do double allocation:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main (void)
{
typedef struct {
char **test;
} Testing;

Testing **p;

/* type of p[0] == Testing * */
p = malloc(sizeof p[0]);
if (!p)
return 1;

/* type of *p[0] == Testing */
p[0] = malloc(sizeof *p[0]);
if (!p[0])
return 1;

/* type of p[0]->test[0] == char * */
p[0]->test = malloc(sizeof p[0]->test[0]);
if (!p[0]->test)
return 1;

/* type of *p[0]->test[0] == char */
p[0]->test[0] = malloc (sizeof *p[0]->test[0] * 20);
if (!p[0]->test[0])
return 1;

strcpy (p[0]->test[0], "Hello World");

printf ("%s\n", p[0]->test[0]);

free(p[0]->test[0]);
free(p[0]->test);
free(p[0]);
free(p);

return 0;
}

[aditya]

Rodrick Brown <rbrown[@]doitt.nyc.gov> wrote in message news:<2004101503155216807%rbrown@doittnycgov>...

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int
main(void)
{
typedef struct
{
char **test;
}Testing;

Testing **p;
p = malloc(sizeof(Testing));
p[0]->test[0] = malloc(sizeof(Testing));
strncpy(p[0]->test[0],"Hello World",20);
printf("%s\n",p[0]->test[0]);

return EXIT_SUCCESS;
}

Why does the following crash ?
Not sure what i'm missing please advise thanks.

strncpy(p[0]->test[0],"Hello World",20);

you have not allocated sufficent amount of memory to the test.

Therefore,when you'll copy the string "hello world" to test,

you will be overwriting the address of the main(void) function.

As a result,the program will crash as soon as return statement will
be executed.

Aditya