5

I am hours trying to figurate out where is the problem, but it seems so strange.

I rewrote my problem in an easier way to understand.

When it gets to the line where it says delete, the debbug makes a breakpoint.

Ps. Intresting to note that, if we take int b1 and move it to Base2 it works.

Base1:

#pragma once
class Base1
{
public:
    Base1();
    ~Base1();
    int b1;
};

Base2.h:

#pragma once
#include <iostream>
#include <vector>
class Derived;
class Base2
{
public:
    Base2();
    ~Base2();
    std::vector <std::vector <Base2*>> vec;
    void doSomething(Derived& d);
};

Base2.cpp:

#include "Base2.h"
#include "Derived.h"


Base2::Base2()
{
    //the numbers 1 and 5 does not really metter
    vec.resize(1);
    vec[0].resize(5);
}


Base2::~Base2()
{
}

void Base2::doSomething(Derived& d)
{
    vec[0][d.b1] = new Derived();
    delete vec[0][d.b1];
}

Derived:

#pragma once
#include "Base1.h"
#include "Base2.h"
class Derived : public Base1, public Base2
{
public:
    Derived();
    ~Derived();
};

main:

#include <iostream>
#include "Derived.h"

int main()
{
    Derived d;
    d.b1 = 1;
    d.doSomething(d);
}
Isaac Michaan
  • 309
  • 1
  • 7
  • I'd advise you to learn about smart pointers; `std::unique_ptr`, `std::shared_ptr` & `std::weak_ptr` (and friends; `std::make_unique`, `std::make_shared`) and stop using manual memory management (raw `new` and `delete`). – Jesper Juhl Dec 27 '18 at 14:23
  • 1
    Undefined behaviour since `Base2` does not have a virtual destructor. You could achieve the same (undefined behaviour, which may or may not result in a runtime error) with `Base2 * p = new Derived; delete p;`. The fact it happens to work by moving `int b1` to `Base2` is happenstance - the behaviour is still undefined. – Peter Dec 27 '18 at 14:25
  • 3
    Thanks guys. So why if move int b1 to Base2 it works? And do I need a Virtual for Base1? or why not? (I will take a look on the duplicate question, it may have an answer there as well - (edited:) it does not have since we are talking about two Bases). – Isaac Michaan Dec 27 '18 at 14:32
  • 1
    Simply put: [undefined behavior is undefined](https://stackoverflow.com/q/2397984/5470596). It's a good read too ;) – YSC Dec 27 '18 at 14:35

1 Answers1

5

Base2 lacks a virtual destructor.

Deleting a derived object via a pointer to it's base, if that base doesn't have a virtual destructor, leads to undefined behavior.

Usually this kind of UB only leads to missing destructor calls (and thus memory/resource leaks), but in this case, since multiple inheritance is involved, the situation is different.

When you convert a pointer returned by new Derived() to Base2 *, the numerical value of the pointer changes (due to multiple inheritance).

After delete calls ~Base2(), it subsequently passes the pointer to a memory deallocation function.
The deallocation function expects the same address that was returned by new, which is the address of an entire Derived instance. Instead it gets an address of Base2 subobject, which is different (again, due to multiple inheritance).

This is no different from any other "attept to delete a pointer that wasn't returned by new" situation, and usually results in a crash.

If Base2 had a virtual destructor, the pointer would be adjusted to point to the entire instance of Derived before deallocation.

HolyBlackCat
  • 78,603
  • 9
  • 131
  • 207