Pointer increments with children of abstract structs

Question

I'm trying to iterate over an array of structs, that are children of an abstract class, by incrementing the pointer to that struct. This works until I add members to that struct, which then results in a memory access violation when trying to derefence the pointer. Here's the code:

struct A {
    virtual float Get() = 0;
};

struct B : A {
    //int val;

    B() {
    // val = 0.f;
    }

    void Set(int v) {
        //val = v;
    }
    
    float Get() override{
        return 0.f; // val;
    }
};

struct C : A {
    A* previous;
    int numPrev;

    C() :
        previous(nullptr),
        numPrev(0)
    {}

    float Get() override {
        float v = 0.f;
        A* p = previous;
        for (int i = 0; i < numPrev; i++) {
            v += p->Get();
            p++;
        }
        return v;
    }

    void Register(A* prev, int count) {
        previous = prev;
        numPrev = count;
    }
};

C* c;
B* b;

int main()
{
    int count = 3;
    b = new B[count]();
    c = new C[count]();

    B* curB = b;
    for (int i = 0; i < count; i++) {
        curB->Set(i);
        curB++;
    }

    C* cur = c;
    for (int i = 0; i < count; i++) {
        cur->Register(b, count);
        cur++;
    }

    float res = 0.f;
    cur = c;
    for (int i = 0; i < count; i++) {
        res += c->Get();
        cur++;
    }

    std::cout << res;

    delete[] b;
    delete[] c;
}

The code above compiles and works fine (as far as I can tell) but if I uncomment all the "val"-stuff in struct B it suddenly throws the mentioned memory access violation. I suspected that the cause might be that "p++" in the Get() method of struct C is incrementing by the wrong amount, because p is a pointer to A but we actually deal with Bs (which are children of A). Adding the member "val" to B would then cause sizeof(B) != sizeof(A) and therefore p++ might not actually jump to the next element but rather "into" the current one causing the violation? Unfortunately changing "p++" to either "p += sizeof(A)" or "p += sizeof(B)" does not solve this, so I'm starting to suspect it's something else...

Does anyone have an idea what could cause this? Am I just blind to a dumb mistake or is there anything else going on?

Thanks a lot in advance!

You are treating an array of `B` as if it were an array of `A`. Since `sizeof(A) != sizeof(B)` the pointer arithmetic inside the `Get` function moves the pointer to wrong addresses — UnholySheep, Aug 11 '20 at 14:22
**Never treat arrays polymorphically**: http://blog.sinzy.net/hjk41/entry/9315 — SergeyA, Aug 11 '20 at 14:25
Nice, thank you! That helps a lot! Does anyone of you know why p += sizeof(B) doesn't work though? I would have thought that this would then move the pointer to the correct adress? Does anyone have a different idea? I tried to use vectors instead but then the problem is that I cant pass a pointer to vector when vector* is expected. I'd like to use pointers to not copy around large arrays/vectors as performance is important here. And I also cant use B as "previous" because C can either hold objects of type B or C as "previous". I appreciate the help! — foodius, Aug 11 '20 at 14:51
Never mind, using A** for c and b seems to solve this (if someone has the same problem). I took that method from Patrick Costello's answer under: https://stackoverflow.com/questions/7196172/can-a-pointer-to-base-point-to-an-array-of-derived-objects — foodius, Aug 11 '20 at 15:22
Re: `p += sizeof(B)` -- pointer arithmetic advances a pointer to point to the next element of its type. That is, `A*p = whatever; p++;` will increment `p` to point to the next `A`. Adding `sizeof(B)` to `p` treats `sizeof(B)` as the **number** of `A`s to skip. — Pete Becker, Aug 11 '20 at 15:28
@user253751 -- more to the point, C does't have inheritance. The problem here has nothing to do with `A` being abstract; the same things would happen if it wasn't. — Pete Becker, Aug 11 '20 at 15:29
@PeteBecker Oh that makes sense, thank you! And my bad for adding "C" to the tags, I didn't know it doesn't have inheritance. — foodius, Aug 11 '20 at 15:45

Pointer increments with children of abstract structs

0 Answers0