#include <iostream>
#include <vector>

class Test
{
public:
	Test();
	~Test();

	void Load();
	int* pointer;
};

Test::Test() :
	pointer(nullptr)
{
}

Test::~Test()
{
	delete pointer;
}

void Test::Load()
{
	pointer = new int(24);
}

std::vector<Test> vec;

void Create()
{
	Test test;
	test.Load();
	vec.push_back(test);
}

int main()
{
	std::wcout << L"Testprogramm:" << std::endl;
	Create();
	std::wcout << *vec.front().pointer << std::endl;
	std::wcout << L"Ende!" << std::endl;
	while(true){};
	return 0;
}

In der Funktion "Create" wird ja eine Kopie des temporären Objects "test" dem Vector "vec" hinzugefügt. Meine Vermutung ist, dass dabei allerdings nicht das Object auf das der Pointer "pointer" zeigt kopiert wird sondern nur der Pointer selber also die Adresse des Objects auf welches er zeigt. Da "test" aber nur temporär ist und das Object auf das "pointer" zeigt im Destructor vernichtet wird zeigt der Pointer der "test"-Kopie die im Vector abgelegt wurde ins Nirvana.
Ist das richtig? Was kann ich tun damit dieser Fehler nicht mehr auftritt?

Gruß

C/C++

#include <iostream>
#include <vector>

class Test
{
public:
    Test();
    ~Test();

    void Load();
    int* pointer;
};

Test::Test() :
    pointer(nullptr)
{
}

Test::~Test()
{
    delete pointer;
}

void Test::Load()
{
    pointer = new int(24);
}

std::vector<Test> vec;

void Create()
{
    Test test;
    test.Load();
    vec.push_back(test);
}

int main()
{
    std::wcout << L"Testprogramm:" << std::endl;
    Create();
    std::wcout << *vec.front().pointer << std::endl;
    std::wcout << L"Ende!" << std::endl;
    while(true){};
    return 0;
}

Die einfachste Lösung besteht wohl darin, keine nackten Zeiger zu verwenden, sondern die Informationen sauber zu verpacken (ein int passt auch direkt ins Objekt, ansonsten such mal nach Containern und Smart-Pointern).

Und drittens hast du die Regel der "Großen Drei" nicht verstanden - beim Kopieren in den vector<> wird eine Kopie von test angelegt und anschließend das Objekt selbst zerstört (letzteres ruft dessen Destruktor auf).

Habe ich doch als Vermutung geschrieben.

Jungs, das ist nur ein Beispielprogramm. Der wirkliche Code sieht ganz anders aus. Ich habe hier nur als Beispiel einen int-Zeiger genommen. Und dass ich diesen nicht im Konstruktor initialisiere ist so gewollt, da der Wert eben auch "NULL" sein können muss.
Smartpointer wollte ich nach Möglichkeit vermeiden.

Und ohne Smart-Pointer bleibt dir nichts anderes übrig, als die Kopier-Operationen auch zu definieren - entweder du kopierst den gesamten Block, den die Load()-Funktion reserviert hat, oder du zählst mit, wieviele Objekte diesen Block nutzen. (möglich sind auch Zwischenlösungen, bei denen du erst kopierst, wenn eins der Objekte den Speicherbereich ändern will)

(das meinte ich dort oben mit den "Großen Drei" - Destruktor, Zuweisung und Kopier-Konstruktor treten grundsätzlich im Team auf.

Jungs, das ist nur ein Beispielprogramm. Der wirkliche Code sieht ganz anders aus.

Warum führst du die Leute dann mit falschem Code aufs Glatteis?

class Handler
{
    ....

    Handler(const Handler & source)
    {
        pointer = source.pointer->Copy();
    }

    ....
    Base * pointer;
};

class Base
{
    ...

    virtual Base * Copy() = 0;

    ...
};

class Real : public Base
{
    ...

    virtual Base * Copy()
    {
        return new Real(*this);
    };

    ...
};

Das kann natürlich noch etwas sauberer ausgeführt werden ...