gcc errors while working in a variable-length pointer array in C

Question

I'm getting this error:

list.c list.h types.h
list.c: In function 'List_push':
list.c:11:23: error: invalid initializer
--- void *values[len] = ls->values);

EDIT:

Now, with my current code (I've done undos/redos that removed somethings), I get this error instead:

Why?

Basically I've a List structure which declares an variable-length array, containing void pointers (what I want is pointers to any data type). You can see it below at the list.h file.

I've tried a mix of changes in list.c (i.e., *values[pos++] = ..., etc...), but doing these changes it only results in worse gcc errors.

wscom.c

#include <stdio.h>
#include <stdlib.h>
#include "list.h"
#include "types.h"

int main() {
    List ls;
    // TEST: Put a value pointer at index 0
    uint8 value = 0x41;
    List_push(&ls, 1, &value);
    printf("%c",
        *(char*) List_getindex(&ls, 0)
    );
    return 0;
}

types.h

#ifndef hydroTrackerTypesH
#define hydroTrackerTypesH

typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned long long uint32;

#endif

list.h (Declarations)

#ifndef hydroTrackerListH
#define hydroTrackerListH

#include "types.h"

typedef struct {
    uint32 length;
    void *values[];
} List;

void  List_push(List *ls, uint8 count, ...);
void *List_getindex(List *ls, uint32 i);
void  List_setindex(List *ls, uint32 i, void *v);

#endif

list.c (Defns.)

#include "list.h"
#include "types.h"
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>

static size_t PointerSize =
    sizeof(void*);

void List_push(List *ls, uint8 count, ...) {
    uint32 len = ls->length;
    void *values[len] = ls->values;
    uint32 sum = len + count;
    realloc(&values, sum * PointerSize);
    ls->length = sum;

    va_list newVals;
    va_start(newVals, count);
    uint8 pos = len;

    while(count--)
        values[pos++] = va_arg(newVals, void*);

    va_end(newVals);
}

void *List_getindex(List *ls, uint32 i) {
    return (void *)(ls->values[i]);
}

//void List_setindex(List *ls, uint32 i, void *v);

Answer 1

This is a little bit long for a comment. Thus, I make it an answer.

I try to show you how pointers and arrays are related to each other:

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

int main()
{
  /* The compiler allocates space for "Hello" and '\0' (5 + 1 chars)
   * and stores the address in aString1.
   */
  const char *aString1 = "Hello";
  /* The compiler allocates 10 chars and initializes
   * it with "World" (and the '\0' for terminator).
   */
  const char aString2[10] = "World";
  /* The compiler determines length of initializer "I'm here."
   * (9 + 1) and allocates the array of appropriate size.
   */
  const char aString3[] = "I'm here.";
  /* allocate storage for array (3 const char*) */
#if 0 /* the usual way */
  const char **array = malloc(3 * sizeof (const char*));
#else /* how Matheus wants to do it */
  const char **array = NULL;
  array = realloc(array, 3 * sizeof (const char*));
#endif /* 0 */
  /* assign contents (using it like an array) */
  array[0] = aString1;
  array[1] = aString2;
  array[2] = aString3;
  /* apply array to another variable array2 */
  const char **array2 = array; /* assigns the address only */
  /* use it: */
  printf("array2[0]: '%s', array2[1]: '%s', array2[2]: '%s'\n",
    array2[0], array2[1], array2[2]);
  /* throw away storage of array (and array2) */
  free(array);
  /* Attention! array, array2 become wild pointers at this point
   * and may not be accessed (except new, valid addresses are assigned).
   * However, aString1, aString2, aString3 are still intact.
   */
  printf("aString1: '%s', aString2: '%s', aString3: '%s'\n",
    aString1, aString2, aString3);
  /* done */
  return 0;
}

The sample can be tested on ideone.com.

The sample output is:

array2[0]: 'Hello', array2[1]: 'World', array2[2]: 'I'm here.'
aString1: 'Hello', aString2: 'World', aString3: 'I'm here.'

Update:

So, I finally looked again on to the question & answer of Matheus and tried to fix it according to his intention (or how I understood it). I based it on Matheus' implementation and remarked modified codes by comments:

list.h:

#ifndef LIST_H
#define LIST_H

#if 0 /* not necessary to define these types */
#include "types.h"
#else /* they are already available in a (better) portable manner: */
#include <stdint.h>
/* Btw. I had to change:
 * uint8 -> uint8_t
 * uint32 -> uint32_t
 */
#endif /* 0 */

typedef struct {
  uint32_t length;
#if 0 /* gcc ERROR: */
  /* list.c:17:3: error: invalid use of flexible array member
   * ls->values = NULL;
   */
  void *values[];
#else /* (not) 0 */
  void **values;
#endif /* 0 */
} List;

void  List_init(List *ls);
void  List_push(List *ls, uint8_t count, ...);
void* List_getindex(List *ls, uint32_t i);
void  List_setindex(List *ls, uint32_t i, void *v);

#endif /* LIST_H */

list.c:

#include "list.h"
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>

#if 0 /* no need for a variable (with storage */
static size_t PointerSize = sizeof(void*);
#else /* use enum instead (constant) */
enum { PointerSize = sizeof(void*) };
#endif /* 0 */

void List_init(List *ls)
{
  ls->length = 0;
  /* This is important: */
  ls->values = NULL;
  /* or 1st realloc() in List_push() may have Undefined Behavior.) */
}

void List_push(List *ls, uint8_t count, ...)
{
  uint32_t len = ls->length;
  uint32_t sum = len + count;
  void **values = realloc(ls->values, sum * PointerSize);
  if (!values) {
    /* realloc() failed! Bail out before destroying the existing data. */
    return;
  }
  ls->length = sum;
  ls->values = values;
  /* assign new contents */
  va_list newVals;
  va_start(newVals, count);
#if 1 /* the readable way: */
  int pos = len;
  while (count--) values[pos++] = va_arg(newVals, void*);
#else /* the hackish C style way: */
  values += len;
  while (count--) *values++ = va_arg(newVals, void*);
#endif /* 1 */
  va_end(newVals);
}

void* List_getindex(List *ls, uint32_t i)
{
  return ls->values[i];
}

wscom.c:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "list.h"

int main()
{
  List ls;
  /* Put a value pointers at indices 0, 1, 2 */
  uint8_t value1 = 0x41, value2 = 0x42;
  uint8_t value3[3] = { 0x43, 0x44, 0x45 };
  List_init(&ls);
  List_push(&ls, 3, &value1, &value2, value3);
  /* Check whether list contents can be retrieved again */
  if ((*(uint8_t*)List_getindex(&ls, 0)) == 0x41) {
    printf("List entry 0 is correct.\n");
  }
  if ((*(uint8_t*)List_getindex(&ls, 1)) == 0x42) {
    printf("List entry 1 is correct.\n");
  }
  { uint8_t *values = List_getindex(&ls, 2);
    if (values[0] == 0x43
      && values[1] == 0x44
      && values[2] == 0x45) {
      printf("List entry 2 is correct.\n");
    }
  }
  /* Done. */
  return 0;
}

In one of my comments, I stated that void *values[]; in struct List might be OK. Ahem, I was wrong. gcc remarks this as error when I tried to use it in list.c. So, actually, it is OK but not for what I intend it to use.

Finally, my sample session (using gcc in cygwin on Windows 10):

$ gcc -std=c11 -o wscom wscom.c list.c

$ ./wscom
List entry 0 is correct.
List entry 1 is correct.
List entry 2 is correct.

$

2^nd Update:

(I believe) I realized the missing piece of Matheus (considering his Javascript background):

There are no dynamic arrays in C (in opposition to Javascript). Instead, there are arrays with variable size which may be used only in specific situations:

In C:

1. Definition of arrays with variable size in global variables is prohibited. (The compiler needs to know how many bytes to allocate for storage.) This does not exclude something like e.g.
   int array[] = { 1, 2, 3 };
   because the compiler determines the size from the initializer (on the right hand side of =).

2. Declaration of global arrays without explicit size is possible. (The definition with proper size might/must be done somewhere else. The linker will fail if no proper storage definition can be found.)

3. A local variable (inside a function, storage class auto but not static or extern) might be declared as array with size determined at runtime (from a variable). This feature was introduced in C99 but not (yet) in C++ (at least not until C++11 incl.)

4. A function parameter might be declared as array with unknown (or any) size. (This is equal to declaring it as a pointer.)

I found a nice answer about this in SO: Dynamic array allocation on stack in C (which I used to prove my own statements above).

The only supported way to have "dynamic arrays" in C is the usage of the standard library functions malloc()/realloc()/free(). However this is better called "dynamic memory" allocation because this applies to any C type (not only arrays).

Disclaimer:

I apologize if I wrote something rubbish about Javascript. I'm the total newbie in Javascript with very less practical experience...