Thread: compiler error: left of ' ' must have struct/union type

I've been experimenting with different types of "queues" of fixed size which I have shown in a previous thread. Now however, I want to design a proper queue of unspecified length that allocates and deallocates memory as members are pushed into the queue at the end or popped out of the queue at the start of it.


So inside each member of the pixelQueue I put a struct named Pixel that contains the all the data I need for that member and a pointer that is pointing to the next member of the queue.


The code that handles this part of the program looks like so:

Code:

...


bool **queuedArray;
int nRows, nCols;
char *inputRow;


typedef struct Pixel {
    int x;
    int y;
} Pixel;


...


typedef struct pixelQueue {
    Pixel element;
    struct pixelQueue *nextMember;
} pixelQueue;
int queueLength;
pixelQueue *firstMember = NULL, *lastMember = NULL;


int queueLength;
void pushQueue(Pixel element);
Pixel popQueue();


...


int main(int argc, const char * argv[]) {
    if(scanf("%d%d", &nRows, &nCols) == 2) {
        allocateMemory();


        ...
    ...
    
    free(queuedArray[0]);
    ...
    free(queuedArray);


    return 0;
}


void allocateMemory() {
    int NROWS = nRows + 2, NCOLS = nCols + 2;
    
    ...
    
    queuedArray = malloc(NROWS * sizeof *queuedArray);
    queuedArray[0] = calloc(NROWS * NCOLS, sizeof **queuedArray);
    
    for(int i = 1; i < NROWS; ++i) {
        ...
        queuedArray[i] = queuedArray[i - 1] + NCOLS;
    }
}


...
...
...


void pushQueue(element) {
   if(queuedArray[element.x][element.y])
       return;
   if(firstMember == NULL) {
      firstMember = malloc(sizeof *firstMember);
      lastMember = firstMember;
      queueLength = 0;
   } else {
      lastMember->nextMember = malloc(sizeof *firstMember);
      lastMember = lastMember->nextMember;
   }
   lastMember->element.x = element.x;
   lastMember->element.y = element.y;
   lastMember->nextMember = NULL;
   ++queueLength;
}


Pixel popQueue() {
   Pixel element;
   if(firstMember == NULL) {
      printf("Empty queue, popQueue() abuse!\n");
      element.x = -1;
      element.y = -1;
      return element;
   }
   element.x = *firstMember.element.x;
   element.y = *firstMember.element.y;
   if(firstMember == lastMember) {
      free(firstMember);
      firstMember = NULL;
      queueLength = 0;
   } else {
      pixelQueue *interimCell;
      interimCell = firstMember.nextMember;
      free(firstMember);
      firstMember = interimCell;
      --queueLength;
   }
   return element;
}


...

The problem however is that I get the errors

Code:

traceCoastLine2c.c(...) : error C2224: left of '.x' must have struct/union type
traceCoastLine2c.c(...) : error C2224: left of '.y' must have struct/union type

at line 72,82 and 83. What's even stranger is that in the previous version of the program before I attempted implementing a dynamic queue the compiler never complained about line 72.


So what is wrong and what is the correct way of managing this?

I really feel like an idiot now, thank you, it works!

So changing from

Code:

void pushQueue(element) {
...
}

to

Code:

void pushQueue(Pixel element) {
...
}

did the trick. Something else that I've been unsure about is the safety of passing around whole structs:

Code:

element = firstMember->coordinate;

That way only the struct as a whole will be passed I figured and not the values of the members of the struct which is why I instead did:

Code:

element.x = firstMember->coordinate.x;
element.y = firstMember->coordinate.y;

But it turns out that both ways work equally fine. I don't know whether this is to be taken for granted in every developer environment though.

However, switching from fixed size queues to dynamic queues dropped the performance from 0.06s to 0.08s, so this was a terrible move on my side.

Perhaps using fixed size array may improve performance further. If I know that the maximum size is 1000 x 1000 elements, then I could allocate a worldArray[1002][1002] at the beginning instead of doing dynamic mallocs.

Interesting, so it isn't that the dynamically allocated memory itself is slower than "statically" allocated memory at the beginning of the program, but the calls to malloc(), calloc() and realloc() that lowers performance it appears.

I didn't know about realloc(), perhaps it is better to use malloc and have separate blocks that each can keep a specified number of queue members after all. Because I cannot see how you partially deallocate parts of a whole block (that is incrementally increased by the realloc() function) once those parts are no longer needed. I see no call to free() in the popQueue() function.

But if the program doesn't clean up after itself, won't the allocated memory stay allocated even after the program terminates? I have a (biological) memory that memory that wasn't freed will remain allocated until next reboot if it isn't taken care of correctly in the binary. Perhaps this is a quirk in Windows while being a non issue in *x environments.