Vector in Vector geht nicht

Hallo,
ich habe folgendes Problem:
Ich habe die Klasse Object (siehe unten). Wenn ich jetzt einen Vector vom Typ Object erstelle (std::vector<Object> objekte) und mir von jedem objekt die Werte per Print() ausgeben lasse, bekomme ich für "foo" (siehe unten) die korrekte (jedes mal eine andere) Ausgabe, jedoch ist der Inhalt von "zahlen" immer gleich.

Es ist vielleicht schwer zu verstehen, was ich damit sagen will, deshalb hier der Quelltext:

#include <vector>
#include <conio.h>

int n;    // zählvariable, um verschiedene Werte zu erhalten

class Object
{
public:
	void Load(int f);    // 'zahlen' mit Werten füllen
	std::vector<int> zahlen;  // vector in dem 10 verschiedene zahlen gespeichert werden
	void Print();     // 'foo' und 'zahlen' ausgeben
	int foo;
};

void Object::Load(int f)
{
	foo = f;
	for(int i = 0; i < 10; i++)
	{
		zahlen.push_back(n);
		n++;
	}
}

void Object::Print()
{
	printf("foo: %i\n", foo);   // hier sieht man, dass wirklich mehrere Instanzen von 'Object' erzeugt und in 'objekte' gespeichert wurden, denn es wird immer ein anderer Wert ausgegeben

	for(int i = 0; i < 10; i++)
	{
		printf("%i\n", zahlen[i]);  // 'zahlen' ausgeben: hier sollten eigentlich bei jeder Instanz von Object andere Werte ausgegeben werden. Ist aber nicht der Fall. Ausgabe lautet immer 0,1,2,...,9
	}
}

int main()
{
	n = 0;
	std::vector<Object> objekte;

	Object *object = new Object();
	for(int i = 0; i < 10; i++)   // 10 Objekte erstellen und in 'objekte' speichern
	{
		object->Load(i);
		objekte.push_back(*object);
	}

	for(int i = 0; i < 10; i++)  // bei allen 10 objekten die Print()-Funktion ausführen
	{
		objekte[i].Print();
	}

    getch();
}

Wenn ich jetzt einen Vector vom Typ Object erstelle und mir von jedem objekt die Werte per Print() ausgeben lasse, bekomme ich für "foo" die korrekte (jedes mal eine andere) Ausgabe, jedoch ist der Inhalt von "zahlen" immer gleich.
Kann das so überhaupt funktionieren? Wie kann ich es richtig machen. Also Ziel des ganzen ist, dass am Ende die Werte ausgegeben werden, die bei Load() eingefügt werden.

*D*Evil

int main()
{
    std::vector<Object> objekte;

    for (std::size_t i = 0; i < 10; ++i)
    {
        Object object;
        object.load(i);
        objekte.push_back(object);
    }

    for (std::size_t i = 0; i < objekte.size(); ++i) 
        objekte[i].print();
}

?!

aja

#include <vector>
#include <iostream>

class Object
{
public:
    void load(const std::size_t&);
    void print() const;

private:
    std::vector<unsigned int> m_digits;
    std::size_t m_foo;
};

void Object::load(const std::size_t& foo)
{
    m_foo = foo;
    for (std::size_t i = 0; i < 10; ++i)
        m_digites.push_back(i);
}

void Object::print() const
{
    std::cout << m_foo << std::endl;
    for (std::size_t i = 0; i < m_digits.size(); ++i)
        std::cout << m_digits[i] << std::endl;
}

Das mit deinem n musse anderes machen ... ne schlechte Idee

Danke, das funktioniert.

Das Programm war ja auch nicht das, was ich verwende, sondern nur ein minimales Beispiel, in dem zwei Vektoren verschachtelt sind. Das n war auf jeden Fall ne schlechte Idee^^

Braunstein

und wenn du Object jetzt noch einen Konstruktor gibst, der ein size_t übernimmt und intern load ausführt, kannst du das so schreiben

int main()
{
    std::vector<Object> objekte;

    for (std::size_t i = 0; i < 10; ++i)
    {
        objekte.push_back(Object(i));
    }

    for (std::size_t i = 0; i < objekte.size(); ++i)
        objekte[i].print();
}

CStoll

Dir ist hoffentlich klar, daß du dort ein Objekt hast das in jedem Durchlauf der Schleife neue Werte anhängt - beim push_back wird dieses Objekt kopiert, aber das globale Objekt bleibt als solches erhalten und verlängert jedes Mal seinen Vector 'zahlen'. Verwende mal ein 'for(int i = 0; i < zahlen.size(); i++)' in der Print()-Methode, dann erkennst du die Unterschiede

Braunstein

Du meinst damit Mr. Vector^^s Variante denke ich.