Question

If I have a typedef of a struct

typedef struct 
{
char    SmType;
char    SRes;
float   SParm;
float   EParm;
WORD    Count;
char    Flags;
char    unused;
GPOINT2 Nodes[];
} GPATH2;

and it contains an uninitialized array, how can I create an instance of this type so that is will hold, say, 4 values in Nodes[]?

Edit: This belongs to an API for a program written in Assembler. I guess as long as the underlying data in memory is the same, an answer changing the struct definition would work, but not if the underlying memory is different. The Assembly Language application is not using this definition …. but …. a C program using it can create GPATH2 elements that the Assembly Language application can “read”.

Can I ever resize Nodes[] once I have created an instance of GPATH2?

Note: I would have placed this with a straight C tag, but there is only a C++ tag.

Answer 1

You could use a bastard mix of C and C++ if you really want to:

#include <new>
#include <cstdlib>

#include "definition_of_GPATH2.h"

using namespace std;

int main(void)
{
    int i;
    /* Allocate raw memory buffer */
    void * raw_buffer = calloc(1, sizeof(GPATH2) + 4 * sizeof(GPOINT2));
    /* Initialize struct with placement-new */
    GPATH2 * path = new (raw_buffer) GPATH2;

    path->Count = 4;
    for ( i = 0 ; i < 4 ; i++ )
    {
        path->Nodes[i].x = rand();
        path->Nodes[i].y = rand();
    }

    /* Resize raw buffer */
    raw_buffer = realloc(raw_buffer, sizeof(GPATH2) + 8 * sizeof(GPOINT2));

    /* 'path' still points to the old buffer that might have been free'd 
     * by realloc, so it has to be re-initialized
     * realloc copies old memory contents, so I am not certain this would
     * work with a proper object that actaully does something in the 
     * constructor
     */
    path = new (raw_buffer) GPATH2;

    /* now we can write more elements of array */
    path->Count = 5;
    path->Nodes[4].x = rand();
    path->Nodes[4].y = rand();

    /* Because this is allocated with malloc/realloc, free it with free
     * rather than delete.
     * If 'path' was a proper object rather than a struct, you should
     * call the destructor manually first.
     */
    free(raw_buffer);

    return 0;
}

Granted, it’s not idiomatic C++ as others have observed, but if the struct is part of legacy code it might be the most straightforward option.

Correctness of the above sample program has only been checked with valgrind using dummy definitions of the structs, your mileage may vary.