Invalid address specified to RtlValidateHeap when deleting pointer to derived class - c++

Question

I have a problem with polymorphism in a C++ project I'm working on. I have a base class named State, and a derived TestState class. I'm trying to call a virtual function overidden in the derived class from a State pointer. The virtual function is called, but when deleting the pointer I get the following error:
Invalid address specified to RtlValidateHeap( 00FF0000, 0018FD74 )
After searching for other answers I've been able to understand that this means that the heap is corrupted, but none of the solutions I've found have worked for me.
This is the code I'm running:
int main()
{
TestState test;
State *state = new State();
state = &test;
state->Init();
delete state;
}
State.h
#pragma once
#include <iostream>
class State
{
public:
State();
virtual ~State();
virtual void Init();
virtual void Reinit();
virtual void Deinit();
};
State.cpp
#include "State.h"
State::State()
{
}
State::~State()
{
std::cout << "Destroying State!" << std::endl;
}
void State::Init()
{
std::cout << "Initialized State!" << std::endl;
}
void State::Deinit()
{
}
void State::Reinit()
{
}
TestState.h
#pragma once
#include "State.h"
#include <iostream>
class TestState : public State
{
public:
TestState();
~TestState();
void Init();
void Deinit();
void Reinit();
};
TestState.cpp
#include "TestState.h"
TestState::TestState()
{
}
TestState::~TestState()
{
std::cout << "Destroying TestState!" << std::endl;
}
void TestState::Init()
{
std::cout << "Initialized TestState!" << std::endl;
}
void TestState::Deinit()
{
}
void TestState::Reinit()
{
}
The destructor of both State and TestState are called when the pointer is deleted.
Thanks in advance.

Answer 1

Because you are deleting something in the stack. When you assign the pointer to a reference to a local variable you assign the pointer to an entity allocated in the stack. It cannot be delete using "delete" which is for heap variables. In addition you are leaking what you allocated with the new.
TestState test;
State *state = new State();
state = &test; //Now it points to the test which is in the stack
state->Init();
delete state; //Delete something in the stack. Not good.
Something like this should work better.
TestState test;
State *state = &test;
state->Init();

Answer 2

Even though the solution to your specific problem was easy (i.e. you were trying to delete a stack-allocated variable as if it was heap-allocated), I wanted to post my solution to my mysterious RtlValidateHeap assertion.
It turns out that the code I was working on had mixed settings between projects for "Runtime library" (in the project properties, under C/C++ -> Code Generation). The application has "Multithreaded Debug", the DLLs had "Multithreaded Debug DLL". They all need to be set to the same thing.
If you mix DLL and non-DLL runtime libraries, you end up with two separate heaps, and it becomes impossible to delete an object allocated under one runtime-library from code using another runtime-library. You end up with mysterious RtlValidateHeap assertions.
Hope this helps someone else.

Answer 3

This is what shared pointers are for :) There is a very good Smart Pointer video by The Cherno on youtube.
This should fix things change your main to this:
#include "TestState.h"
#include "State.h"
#include <memory>
int main()
{
{
std::shared_ptr<TestState> test = std::make_shared<TestState>();
std::shared_ptr<TestState> state = test;
state->Init();
}
//delete state;
}