Structures via pointers giving different results to direct dot access

[Ernst Blofeld]

i can't figure this out.

This code:

void __Eurofighter_construct(void * _eurofighter /* position, orientation */) {
    KPrintF("In __Eurofighter_construct.");

    KPrintF("// these things work:");

    BSPModelData * b = &eurofighterBSPModelData;
    KPrintF("  b->modelData.numVertices = %ld", b->modelData.numVertices);

    ModelData * m = (ModelData *) b;
    KPrintF("  m->numVertices = %ld", m->numVertices);

    KPrintF("// but this doesn't:");

    KPrintF("  eurofighterBSPModelData.modelData.numVertices = %d", eurofighterBSPModelData.modelData.numVertices);

    KPrintF("Huh.");

    BSPModel * eurofighterModel = new_BSPModel(&eurofighterBSPModelData);

    __EntityWithModel_construct((EntityWithModel *) _eurofighter, /* position, orientation */ (Model *) eurofighterModel);
}

Results in this output:

In __Eurofighter_construct.
// these things work:
  b->modelData.numVertices = 52
  m->numVertices = 52
// but this doesn't:
  eurofighterBSPModelData.modelData.numVertices = 0
Huh.

I expect numVertices should be 52 in all 3 cases, it's the same data... I don't understand why the last one comes as 0.

The structure ModelData is defined like this:

typedef struct modelData {
    UWORD numVertices;
    Point3D * vertices;
} ModelData;

and BSPModelData is this:

typedef struct bspModelData {
    ModelData modelData;
    Section * bspTreeRoot;
} BSPModelData;

And the data being printed is:

static BSPModelData eurofighterBSPModelData = {
    .modelData = {
        .numVertices = EUROFIGHTER_NUM_VERTICES,
        .vertices = vertices
    },
    .bspTreeRoot = (Section *) &eurofighterSection
};

Where EUROFIGHTER_NUM_VERTICES is #defined to be 52.

Any ideas?

[Samurai_Crow]

Using a dot operator with a pointer requires you dereference using a star.

[thomas]

KPrintF(" eurofighterBSPModelData.modelData.numVertices = %d"

This should read %ld, like in the other places.

The code is correct, the debugging isn't.

[Ernst Blofeld]

Originally Posted by Samurai_Crow

Using a dot operator with a pointer requires you dereference using a star.

There are 14 stars in my post. Do I not have enough?

[thomas]

In case you missed my post: your code is doing what you expect. Your debug output is wrong.

[Ernst Blofeld]

Originally Posted by thomas

KPrintF(" eurofighterBSPModelData.modelData.numVertices = %d"

This should read %ld, like in the other places.

The code is correct, the debugging isn't.

Well, spotted. Fixing that changes the output to:

// but this doesn't:
  eurofighterBSPModelData.modelData.numVertices = 52
Huh.

So my problem must be elsewhere.

Thanks!

[Ernst Blofeld]

Found it.

I had:

    Model * model = (Model *) model;

instead of

    Model * model = (Model *) _model;

Not sure how this compiles, but

    Model * wibble = (Model *) wibble;

also compiles, and wibble definitely doesn't exist anywhere else in my code.

I think the best thing for me to do is to rework my variable naming to make this less likely to happen again.

Edit:

    Model * wobble = wobble;

also compiles, so I assume there's part of the language standard I don't understand.

[Samurai_Crow]

C isn't picky. It just assumes you are right even if you aren't.

[thomas]

Originally Posted by Ernst Blofeld

Not sure how this compiles, but

    Model * wibble = (Model *) wibble;

also compiles, and wibble definitely doesn't exist anywhere else in my code.

Why do you say it does not exist? You make it exist kust by that line.

The line is just a short form of

Model *wibble;
wibble = (Model *)wibble;

What you really should do is to avoid all that casting. Use proper types for your variables.

For example in your first post instead of

ModelData *m = (ModelData *) b;

you should use

ModelData *m = &b->modelData;

This way the compiller can help you. If you use casting you tell the compiler that you know better than him. But obviously you don't.

[Ernst Blofeld]

Originally Posted by thomas

Why do you say it does not exist? You make it exist kust by that line.

The line is just a short form of

Model *wibble;
wibble = (Model *)wibble;

What you really should do is to avoid all that casting. Use proper types for your variables.

For example in your first post instead of

ModelData *m = (ModelData *) b;

you should use

ModelData *m = &b->modelData;

This way the compiller can help you. If you use casting you tell the compiler that you know better than him. But obviously you don't.

Sure, but that doesn't work the other way, getting from a ModelData * to a BSPModelData *, so I'd end up with two approaches in the same code base.

[defor]

Originally Posted by Ernst Blofeld

Sure, but that doesn't work the other way, getting from a ModelData * to a BSPModelData *, so I'd end up with two approaches in the same code base.

Using C++ isn't an option for you?

[Ernst Blofeld]

Originally Posted by defor

Using C++ isn't an option for you?

I could, and for the relatively simple stuff I'm doing it would probably result in almost identical results when compiled, but I, personally, just don't want to.