Possible Duplicate:
passing array of structure as a function parameter
What is the best way to pass one structure array from one function to another?
Lets say I have
funcion1(){
struct album_ {
int num_tracks;
struct tracks_ tracks;
int playlist_hits[];
};
typedef struct album_ album;
album all_album[50];
}
function2(){
}
How would I pass all_album[50]; to function2()?
struct is like any other type. You can just pass it like how you pass an integer array. If you declare (like above) as global, you don't need to pass at all.
void myFunc( album* A, int N )
{
int i;
for( i = 0; i < N; i++ )
A[i].num_tracks = 0;
}
void main()
{
album MyAlbums[50];
myFunc( MyAlbums, 50 );
}
50 in the call to myFunc() you could use sizeof MyAlbums / sizeof *MyAlbums and avoid another use of a magic constant :)
As either an array of fixed-size, or as a pointer and size pair.
struct tracks_ {
};
struct album_ {
int num_tracks;
struct tracks_ tracks;
int playlist_hits[];
};
typedef struct album_ album;
album all_album[50];
void foo(album all_album[50]) {
//passes this way
}
void foo2(album* all_album, size_t size) { //or degrades to a pointer
}
int main() {
foo(all_album);
foo2(all_album, 50);
}
foo isn't doing what you think it's doing. In the context of a function parameter declaration, T a[N] and T a[] are identical to T *a; in the function foo, all_album is a pointer, not an array.For passing any array of type T to a function, you generally write a function that accepts a pointer to T and a separate size parameter:
void foo(album *a, size_t size) { ... }
to which you pass the array expression and a size:
int main(void)
{
...
album all_album [N];
...
foo(all_album , sizeof all_album / sizeof *all_album )
...
}
Except when it is the operand of the sizeof or unary & operators, or is a string literal being used to initialize another array in a declaration, an expression of type "N-element array of T" will be replaced with an expression of type "pointer to T" whose value is the address of the first element of the array.
IOW, when you write
foo(all_album, sizeof all_album / sizeof *all_album);
several things happen.
The first all_album expression is replaced with a pointer expression whose value is &all_album[0]; this is why the type of a in the definition for foo has type album *.
The sizeof all_album expression evaluates to the total number of bytes in the array. Since all_album is an operand of the sizeof operator, it is not converted to a pointer expression.
The sizeof *all_album expression evaluates to the number of bytes in a single object of type album. Since all_album is not an operand of sizeof (the expression *all_album is the operand), it is first converted to an expression of type "pointer to album". The * operand is applied to that pointer expression, yielding a new expression of type album, which is evaluated by sizeof.
sizeof all_album / sizeof *all_album is evaluated, yielding the number of elements in the array. This value is what gets passed as the size parameter in the definition of foo.