iterate through null terminated array - c

Question

I want to iterate through null terminated structure array.
While loop works fine, but when I try to access any structure fields I get "segfault" in response. What am I doing wrong?
PS I know that it is possible to determine array size and use simple "for" construction. I just want to figure out the source of the problem.
PSS Ok, if array initialization is wrong - how to do it correctly?
#include <stdio.h>
#include <stdlib.h>
typedef struct demo
{
int a;
int b;
int c;
} demo;
demo * fieldDefinitions[] =
{
{ 1 , 1, 1 },
{ 2 , 2, 2 },
{ 3 , 3, 3 },
NULL
};
int main()
{
demo ** ptr = fieldDefinitions;
printf( "Array: %d \n", &fieldDefinitions );
while ( *ptr != NULL )
{
printf( "ptr: %d \n", ptr );
printf( "ptr: %d \n", (**ptr).a ); // <--- problem here
ptr++;
}
return 0;
}

Answer 1

As the others already've pointed out: Listen to your compiler, a standard conforming implementation must complain about:
demo * fieldDefinitions[] =
{
{ 1 , 1, 1 }, // <-- note that this is not a pointer to a demo.
{ 2 , 2, 2 },
{ 3 , 3, 3 },
NULL
};
Also, use p as the printf format specifier for pointers, not d (which is for integer types).
You need pointers to demo objects, so these objects need to be created somehow, so that we can take their addresses. C99 added a feature called compound literals (looking somewhat similar to a cast, however, they are something different) creating unnamed objects:
#include <stdio.h>
#include <stdlib.h>
typedef struct demo
{
int a;
int b;
int c;
} demo;
demo * fieldDefinitions[] =
{
&(demo){ 1 , 1, 1 },
&(demo){ 2 , 2, 2 },
&(demo){ 3 , 3, 3 },
NULL
};
int main()
{
demo ** ptr = fieldDefinitions;
printf( "Array: %p \n", (void *)&fieldDefinitions );
for ( ; *ptr != NULL; ptr++ )
{
printf( "ptr: %p\n", (void *)ptr); // I'm not sure, what you really wanted ...
printf( "*ptr: %p\n", (void *)*ptr ); // ... but I think you meant this
printf( "ptr: %d\n", (*ptr)->a ); // or (**ptr).a, whatever you prefer
}
return 0;
}
The lifetime of an object created via a compound literal is that of the enclosing block or static if used in an initializer for an identifier with static storage duration (as in this example).
HTH

Answer 2

demo * fieldDefinitions[ 4 ] =
{
{ 1 , 1, 1 },
{ 2 , 2, 2 },
{ 3 , 3, 3 },
NULL
};
You can't do that, as you can not do:
int *arr[] = {1, 2, 3, NULL};
Turning your warnings on you get:
initialization makes pointer from integer without a cast
If you want to use pointer arithmetic you can do somenting like:
#include <stdio.h>
#include <stdlib.h>
typedef struct demo
{
int a;
int b;
int c;
} demo;
demo fieldDefinitions[] = {
{ 1 , 1, 1 },
{ 2 , 2, 2 },
{ 3 , 3, 3 },
};
int main(void)
{
demo *ptr = fieldDefinitions;
demo *end = &fieldDefinitions[sizeof(fieldDefinitions) / sizeof(fieldDefinitions[0]) - 1];
do {
printf( "ptr: %p \n", (void *)ptr);
printf( "ptr: %d \n", ptr->a);
} while (ptr++ < end);
return 0;
}

Answer 3

demo * fieldDefinitions[] =
{
{ 1 , 1, 1 },
{ 2 , 2, 2 },
{ 3 , 3, 3 },
NULL
};
you are claiming that fieldDefinitions will be an array of demo object pointers, but instead you are giving objects themselves.This is the way you initialize an array of structures (except NULL at the end). If your array is static then i suggest creating array of demo with known size such as
unsigned const int fieldDefinitions_size = 3;
demo fieldDefinitions_arr[fieldDefinitions_size] = {
{1,1,1},
{2,2,2},
{3,3,3}
};
And iterate by using fieldDefinitions_size.
Or if you insist on having demo pointer array then you can individually allocate memory for each demo object and assign addresses to fieldDefinitions array. This thread will be useful.