C / C++ / MFC

typedef struct {
....
....
        char* file_name[0];         /* File name in Unicode. */
};  // warning C4094: untagged 'struct' declared no symbols

typedef struct {
....
....
        char* file_name[0];         /* File name in Unicode. */
} myStruct;
// myStruct is now an alias for the above structure

struct foo
{
    int i;
    char text[0];
};

// ... other code

struct foo* myFoo = (struct foo*)malloc(sizeof(struct foo) + 20); // additional 20 bytes for the char data.

Stefan_Lang wrote:

it doesn't make any sense at all.

static inline int struct_cmp(const air_t left, const air_t right)
{
	return memcmp(&left, &right, sizeof(air_t));
}

static inline int struct_cmp(const air_t* left, const air_t* right)
{
    return memcmp(left, right, sizeof(air_t));
}

// and you would then call it by something like:

static int some_function(const geometry_t* geometry)
{
    // assuming that part_type is an offset rather than a pointer
    if (struct_cmp(&geometry->part_type, &GEOM_TYPE_X) == 0)
    return 1;
    
    return 0; 
} 

typedef struct geometry_struct geometry_t;

struct geometry_struct
{
    char          name[128];
    char          info[128];
    unsigned long long      org_offset;
    unsigned long long      sb_offset;
    unsigned int  sb_size;
    air_t    part_type;
    unsigned int  geom_type;
    status_type_t status;
    unsigned int  order;
    errcode_type_t errcode;
    const fnct_t *air;
};

const air_t GEOM_TYPE_X = {0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0}};

struct foo {
    short s;
    double d;
};

_Flaviu wrote:

do you suggest me another safe method to compare structs ? A little code sample will be great !

struct foo
{
    short s;
    double d;

    bool equals( struct foo f )
    {
        // this is not the preferred method for comparing floating-point values (but that's not the point)
        return (this->s == f.s) && (this->d == f.d);
    }
};

David Crow wrote:

bool equals( struct foo f )
{
// this is not the preferred method for comparing floating-point values
return (this->s == f.s) && (this->d == f.d);
}

$ cat ex.c
#include <stdio.h>

int main()
{
    double d = 0.0;
    const double one = 1.0;

    for(size_t i = 0; i < 100; ++i)
        d += 0.01;

    // we would expect d now to be 1.0, but ...

    printf("d = %8.6f\n", d);    // output looks like 1.000000
    printf("d == 1.0 => %d\n", d == one);  // but comparison fails
    printf("1.0 - d = %g\n", one -d);  // there's a very small diff btwn d and 1.0

    return 0;
}
$ ./ex
d = 1.000000
d == 1.0 => 0
1.0 - d = -6.66134e-16
$ 

struct foo {
   short s;
   double d;
   char str[24];
};

int compare_foo(const struct foo *f1, const struct foo *f2)
{
    int retval;

    if( (retval =  f1->s - f2->s) != 0)
        return retval;

    if( (retval = f1->d - f2->d) != 0)
         return retval;

    return strcmp(f1->str, f2->str);
}