Thread: structure array function

Remember that any time you pass an array to a function, it's in effect a pointer. Thus, you always end up using it like a "normal" variable, not a pointer. See, you're doing two things:

Code:

void printssinfo(struct ssinfo *peoples);

Which is just a pointer to one instance of a structure. Thus, you could do:

Code:

int main( void )
{
    int x = 0;
    ...people here...
    for( x = 0; x < 5; x++ )
        printssinfo( &people[x] );
}

And modify your function so it's like...

Code:

void printssinfo( struct ssinfo *s )
{
    printf("%s, %s ", s->name.lname, s->name.fname );
    ...blah blah blah...
}

But what you're doing instead, is passing an array like you'd normally pass an array. Thus, it is not a pointer to an instance, it's a "normal array", so you treat it like you normally would use an array.

Quzah.
}

Code:

void foo1( struct bar * ); /* a function that takes a pointer to a structure */
void foo2( struct bar * ); /* a function that takes an array of structures */

Now think about each of these. Forget that they're structures:

Code:

void foo1( int *bar ); /* a function that takes a pointer to an object */
void foo2( int *bar ); /* a function that takes an array of objects */

How do you use a single object which is being pointed to when passed?

Code:

void foo( int *bar )
{
    *bar = blahblahblah;
}

How do you use an array when passed?

Code:

void foo2( int *x )
{
    x[0] = blahblahblah;
}

There you can see two ways of doing the same thing. However, remember that when you use an array, you're using the [ ] to effectively dereference it for you. That's why when you're using structures, and you use it as if it were an array, you use the . instead of the -> operator.

Now, then, you have two ways (three, if you pass a pointer to an array, .. no, not a pointer to a member of the array, a pointer to the whole array members of the array.)

So, if you want to use [ ], then use your dot. If you want the arrow, use it as a pointer, and move down the chain. Or, if you want to use both, use a pointer to an array.

Code:

void foo1( struct bar * x )
{
    x->foobar = blahblahblah;
}

void foo2( struct bar * x )
{
    x[0].foobar = blahblahblah;
}

But remember, just because an array can act like a pointer some times, doesn't mean it can in all cases.

Quzah.

Originally Posted by tjohnsson

in couple words:
plah without [] is pointer
[/code]

No, plah is an array.
sizeof plah = 5*sizeof(int) which in all probability will be larger than sizeof(int *)
try this out

Code:

#include <stdio.h>

int
main(void)
{
     int plah[5];
     int *blah;
     printf("sizeof plah=%d\tsizeof blah=%d\n",(int) sizeof plah,(int) sizeof blah);
     return 0;
}

Originally Posted by tjohnsson

No plah is a pointer
read your self, this explains also why it has a different size.

http://www.absoft.com/Products/Compi.../clrc03ary.htm

by the way... there's misprint on my last message
1. n = 2289432 // pointer address
pointer value is address of array first element...

Please read the webpage

Except in certain contexts, an unsubscripted array name (for example, region instead of region[4]) represents a pointer whose value is the address of the first element of the array, provided that the array has previously been declared.

Representing a pointer is not the same as being a pointer.

If plah is a pointer you can assign values to it, why don't you try doing something like

Code:

int plah[20],x;
int *blah;  
blah=&x;
plah=blah;

and see what happens.

However when a pointer is assigned the value plah it points to the address of the first element of the array which it represents.

Code:

int plah[20];
int *blah;
blah=plah; /* equivalent to blah=&plah[0]*/

Pinko's right. You're wrong. Read the FAQ on the topic.

Quzah.

>I Still wont agree with that...
Then start being more specific so that people won't misunderstand you. An array is not a pointer, this much is certain. However, in most cases, an array name is converted to a pointer to the first element of the array before use.

It still is not a pointer. An array name is not a pointer. If it were, you could simply assign it to something else:

Code:

char foo[] = "foo";
char bar[] = "bar";
char *ffoo, *bbar;

foo = bar; /* If "foo" were in fact a pointer, you could do this. */
ffoo = foo; /* "ffoo" is in fact a pointer, so yes, you can do this */
bbar = foo;

Likewise, you can't pass a pointer to an array to a function, and assign it something else. If it were a "normal pointer", you could:

Code:

#include <stdio.h>
void foobar( char **ffoo, char **bbar )
{
        *ffoo = *bbar;
}

int main( void )
{
        char foo[] = "hello";
        char bar[] = "world";
        char *ffoo = foo;
        char *bbar = bar;

        foobar( &foo, &bar ); /* Ooops, it's not a pointer. Gee, too bad. */
        printf("%s\n", foo );
        printf("%s\n", bar );

        foobar( &ffoo, &bbar ); /* Well, these are, thus, this is valid. */
        printf("%s\n", ffoo );
        printf("%s\n", bbar );
        return 0;
}

So as much as you want it to be a "real pointer", it's not. It never will be. You can't give it new lvalues. You can't treat it fully like you would a real pointer. Thus, it's not a "real pointer".

:beatingadeadhorse:

Damn. I was sure there was a little smiley for that...

Quzah.

foobar( &foo, &bar ); /* Ooops, it's not a pointer. Gee, too bad. */
...
void foobar( char **ffoo, char **bbar )
{
*ffoo = *bbar;
}

&foo, &bar does not have much effect
because ( &foo == foo )

pointer foo and bar is declared as an array...

:thathorseisjustaimageofyou:

>It just looks like you just don't get it
Um, your example is wrong. A pointer to a pointer is not the same as a pointer to an array. Your understanding is close, but not quite right. An array name is not a pointer, it's an array. When used in a value context, that name is converted to a pointer to the first element of the array and when used in an object context the name remains an array. The only object contexts for an array are as an operand to the sizeof or address-of operators, and as a string literal initializer.

The end result is for the most part the same with your understanding, but how it goes about it is where your confusion lies I think.