#include<iostream>
#include<string>

using namespace std;

int HAnzahl = 0;
int WAnzahl = 0;

struct Attribute
{
	string Name;
	double Wert;
	int Nummer;
};

struct Handschuh
{
	Attribute attribute;
};

struct Werkzeug
{
	Attribute attribute;
};
void H_Handschuh(Handschuh * h)
{ 
    cout << "Folgende Handschuhe " << HAnzahl << " sind in der Datenbank vorhanden:" << endl; 
	for (int i=0; i<HAnzahl; i++) 
    { 
        cout << "Handschuh Nummer: " << h[i].attribute.Nummer << endl; 
        cout << "Handschuh Name: " << h[i].attribute.Name << endl; 
		cout << "Handschuh Wert: " << h[i].attribute.Wert << " Euro" << endl; 
    }
}
void W_Werkzeug(Werkzeug *w)
{
	cout << "Folgende Werkzeuge " << WAnzahl << " Sind in der Datenbank:" << endl;
	for (int i=0; i<WAnzahl; i++)
	{
		cout << "Werzeug Nummer: " << w[i].attribute.Nummer << endl;
		cout << "Werzeug Name: " << w[i].attribute.Name << endl;
		cout << "Werzeug Wert: " << w[i].attribute.Wert << endl;
	}
}
int main()
{
	Handschuh alle_Handschuhe[3];

	Handschuh handschuh;

	Handschuh Plastik;
	handschuh.attribute.Nummer = 1;
	handschuh.attribute.Name = "Plastikhandschuh";
	handschuh.attribute.Wert = 2.99;
	alle_Handschuhe[HAnzahl++] = Plastik;

	Handschuh Leder;
	handschuh.attribute.Nummer = 2;
	handschuh.attribute.Name = "Lederhandschuh";
	handschuh.attribute.Wert = 19.99;
	alle_Handschuhe[HAnzahl++] = Leder;

	Handschuh Stoff;
	handschuh.attribute.Nummer = 3;
	handschuh.attribute.Name = "Stoffhandschuh";
	handschuh.attribute.Wert = 4.99;
	alle_Handschuhe[HAnzahl++] = Stoff;

	H_Handschuh(alle_Handschuhe);

	Werkzeug alle_Werkzeuge[2];

	Werkzeug Hammer;
	handschuh.attribute.Nummer = 1;
	handschuh.attribute.Name = "Hammer";
	handschuh.attribute.Wert = 9.99;
	alle_Werkzeuge[WAnzahl++] = Hammer;

	Werkzeug Zange;
	handschuh.attribute.Nummer = 2;
	handschuh.attribute.Name = "Zange";
	handschuh.attribute.Wert = 4.99;
	alle_Werkzeuge[WAnzahl++] = Zange;

	cin.get();
	return 0;
}

"struct Werkzeug" kam hinzu, als ich mich zwei Strukturen zuwenden wollte (dabei ist Attribute entstanden(war vorher in Handschuh und es hatte alles wunderbar geklappt)) und diese verschachteln wollte.
Doch dabei scheint mir irgendein Fehler unterlaufen zu sein, den ich aber leider nicht finden kann.
Zum einen fehlen die Daten zu den Werkzeugen und zum andern...naja seht selbst
Ausgabe:

Folgende Handschuhe 3 sind in der Datenbank vorhanden:
Handschuh Nummer: -858993460
Handschuh Name:
Handschuh Wert: -9.25596e+061 Euro
Handschuh Nummer: -858993460
Handschuh Name:
Handschuh Wert: -9.25596e+061 Euro
Handschuh Nummer: -858993460
Handschuh Name:
Handschuh Wert: -9.25596e+061 Euro

Bitte um einen kleinen Tipp, woran es liegt.
Vielen Dank.

Schöne Grüße,

Stryke

Handschuh Plastik;
    handschuh.attribute.Nummer = 1;
    handschuh.attribute.Name = "Plastikhandschuh";
    handschuh.attribute.Wert = 2.99;
    alle_Handschuhe[HAnzahl++] = Plastik;

Schau es dir mal ganz genau an, was fällt dir auf?

W_Werkzeug(alle_Werkzeuge);

am Ende des Codes vergessen hatte

Handschuh Plastik; // !
    handschuh.....; // ?
    handschuh.....; // ?
    handschuh.....; // ?
    alle_Handschuhe[HAnzahl++] = Plastik; // !

Erkennst du was?

Handschuh Plastik; // !
    Plastik.....; // ! :D
    Plastik.....; // ! :D
    Plastik.....; // ! :D
    alle_Handschuhe[HAnzahl++] = Plastik; // !

Natürlich logisch

Ich danke dir und verneige mich

Ich danke dir und verneige mich

Gern

Könnte ich die Ausgabe in die main() schreiben? Und wenn ja, inwiefern würde sich der Code unterscheiden von dem, wie er jetzt dort steht.

Ansonsten noch ein paar Anmerkungen zu deinem Code:
1. Versuche, globale Variablen unbedingt zu vermeiden.
2. Eine Struktur mit nur einem Element, etwas merkwürdig.
3. Du benutzt std::string , das ist gut. Du benutzt jedoch keine anderen STL-Container, das ist schlecht. Schau dir mal std::vector und std::array an.

Könnte ich die Ausgabe in die main() schreiben? Und wenn ja, inwiefern würde sich der Code unterscheiden von dem, wie er jetzt dort steht.

Würde ich nicht machen. Es ist ein guter Stil, Dinge auszulagern. Idealerweise hast du in der main-Funktion ausschließlich Funktionsaufrufe stehen. Wenn du eine Ausgabe machen willst, dann gibt es eine Funktion die etwas ausgibt. Wenn du etwas einlesen willst, dann gibt es eine Funktion die etwas einliest. Natürlich machst du jetzt nicht für jede Anweisung eine Funktion. Aber das Ziel sollte sein, Funtionen so klein wie möglich zu halten. Es gab hier mal eine Diskussion, wie groß eine Funktion sein sollte. Bei den meisten hat eine Funktion max. 30 Zeilen. Wenn du jetzt mal eine Funktion hast, die mehr als 30 Zeilen hat, heißt das für dich jetzt nicht gleich "oh shit", sondern ist nur ein Hinweis, dass es in deiner Funktion eventuell etwas gibt, das eventuell besser in eine eigenständige Funktion ausgelagert werden sollte.

Falls du Visual Studio als IDE benutzt, irgendeine Version außer Express, empfehle ich dir mal Visual Assist X zu installieren. Klickst du dann auf ein Objekt drauf, wird das Objekt im kompletten Scope farblich markiert, dann erkennst du gleich, wo du es benutzt und wo nicht. Wie es bei anderen IDEs ist, weiß ich nicht, ich benutze nur VS.

gemacht

out schrieb:

1. Versuche, globale Variablen unbedingt zu vermeiden.

Verstehe, was du meinst, aber ich hab mich jetzt rumprobiert. In der Struktur darf nur deklariert werden, in dem Funktionsaufruf und in der main-Funktion funktioniert es nicht. Meinst du, ich solle mit Pointern arbeiten?

out schrieb:

2. Eine Struktur mit nur einem Element, etwas merkwürdig.

Weiß mir nicht anders zu helfen, so wird es derzeit in meinem Buch gemacht.

out schrieb:

3. Du benutzt std::string , das ist gut. Du benutzt jedoch keine anderen STL-Container, das ist schlecht. Schau dir mal std::vector und std::array an.

Benötige ich in dem Code auch nicht, oder lediglich um etwas zu vereinfachen?
Und lohnt es sich lieber jedesmal std::string zu schreiben oder reicht das namepsace std?

Bei Funktionen mit über 30 Zeilen bin ich ja noch nicht, aber falls es kommt, nehm ich dir deinen Ratschlag zu Herzen.

out schrieb:

1. Versuche, globale Variablen unbedingt zu vermeiden.

Verstehe, was du meinst, aber ich hab mich jetzt rumprobiert. In der Struktur darf nur deklariert werden, in dem Funktionsaufruf und in der main-Funktion funktioniert es nicht. Meinst du, ich solle mit Pointern arbeiten?

Eine Anzahl-Variable benötigst du überhaupt nicht. Was du benötigst, ist std::vector , ein dynamisches Array. Dieser hat die Elementfunktion size , damit erhälst du die Größe deines dynamischen Arrays.

xStrykex schrieb:

out schrieb:

2. Eine Struktur mit nur einem Element, etwas merkwürdig.

Weiß mir nicht anders zu helfen, so wird es derzeit in meinem Buch gemacht.

Was liest du für ein Buch. Naja wenn alle Strukturen dieselben Elemente haben, sollte es wohl eher eine einzige Struktur names Gegenstand geben, die ein zusätzliches Element was-für-ein-gegenstand hat.

xStrykex schrieb:

Und lohnt es sich lieber jedesmal std::string zu schreiben oder reicht das namepsace std?

std::string zu schreiben ist besser, weil du damit nicht den gesamten Namensraum std ausschüttest.

xStrykex schrieb:

out schrieb:

1. Versuche, globale Variablen unbedingt zu vermeiden.

Verstehe, was du meinst, aber ich hab mich jetzt rumprobiert. In der Struktur darf nur deklariert werden, in dem Funktionsaufruf und in der main-Funktion funktioniert es nicht. Meinst du, ich solle mit Pointern arbeiten?

Eine Anzahl-Variable benötigst du überhaupt nicht. Was du benötigst, ist std::vector , ein dynamisches Array. Dieser hat die Elementfunktion size , damit erhälst du die Größe deines dynamischen Arrays.

Grade nochmal nachgeschaut, weil mir das bekannt vorkam und dabei auf cstddef gekommen, wäre das nicht vllt sinnvoller als vectoren? (hab mir meinen Code angeguckt und weiß nicht, was ich wie in einen vector umschreiben soll :/)

out schrieb:

xStrykex schrieb:

out schrieb:

2. Eine Struktur mit nur einem Element, etwas merkwürdig.

Weiß mir nicht anders zu helfen, so wird es derzeit in meinem Buch gemacht.

Was liest du für ein Buch. Naja wenn alle Strukturen dieselben Elemente haben, sollte es wohl eher eine einzige Struktur names Gegenstand geben, die ein zusätzliches Element was-für-ein-gegenstand hat.

Ok, versuche mich dran, das mal umzuschreiben.

out schrieb:

xStrykex schrieb:

Und lohnt es sich lieber jedesmal std::string zu schreiben oder reicht das namepsace std?

std::string zu schreiben ist besser, weil du damit nicht den gesamten Namensraum std ausschüttest.

Ok.

Grade nochmal nachgeschaut, weil mir das bekannt vorkam und dabei auf cstddef gekommen, wäre das nicht vllt sinnvoller als vectoren?

Wie meinst du das?

xStrykex schrieb:

hab mir meinen Code angeguckt und weiß nicht, was ich wie in einen vector umschreiben soll

So z.B.:

#include <iostream>
#include <string>
#include <vector>

struct Gegenstand
{
    std::string Name;
    double Wert;
    int Nummer;
};

void H_Handschuh( const std::vector<Gegenstand>& Handschuhe )
{
	std::cout << "Folgende Handschuhe " << Handschuhe.size() << " sind in der Datenbank vorhanden:" << '\n';
    for(int i=0; i<Handschuhe.size(); ++i)
    {
        std::cout << "Handschuh Nummer: " << Handschuhe[i].Nummer << '\n';
        std::cout << "Handschuh Name: "   << Handschuhe[i].Name   << '\n';
        std::cout << "Handschuh Wert: "   << Handschuhe[i].Wert   << " Euro" << '\n';
    }
}

int main()
{
	std::vector<Gegenstand> Handschuhe;

	Gegenstand Plastik_Handschuh;
	Plastik_Handschuh.Nummer = 1;
    Plastik_Handschuh.Name   = "Plastikhandschuh";
    Plastik_Handschuh.Wert   = 2.99;
	Handschuhe.push_back( Plastik_Handschuh );

	Gegenstand Leder_Handschuh;
    Leder_Handschuh.Nummer = 2;
    Leder_Handschuh.Name   = "Lederhandschuh";
    Leder_Handschuh.Wert   = 19.99;
	Handschuhe.push_back( Leder_Handschuh );

	H_Handschuh( Handschuhe );

    std::cin.get();
    return 0;
}

struct

habe ich es so ähnlich verushct, klappt aber nicht.
Ist das eine Referenz, die du in

void H_Handschuh( const std::vector<Gegenstand>& Handschuhe )

verwendet hast? Damit habe ich noch gar net gearbeitet

out schrieb:

xStrykex schrieb:

Grade nochmal nachgeschaut, weil mir das bekannt vorkam und dabei auf cstddef gekommen, wäre das nicht vllt sinnvoller als vectoren?

Wie meinst du das?

#include<cstddef>
//...
for(size_t i = 0; i < Handschuh.size(); ++i) {
cout << "Werzeug Nummer: " << w[i].attribute.Nummer << endl;

Problem dabei ist, bzw ebenso eine Frage, dass es eine Konstante sein muss und keine Variable. Kann man da irgendwie tricksen?

Mir fällt grade auf, dass in meinem Buch (bisher) immer beides eingebunden wurde:

#include<vector> // Standard-Vektor bekannt machen
#include<cstddef> // size_t

Ich bin grade etwas verwirrt, also hab Nachsicht, wenn ich etwas Unsinniges geschrieben habe.
Ich versteh mein eigenes Wort grade nicht mehr

Ist das eine Referenz, die du in

void H_Handschuh( const std::vector<Gegenstand>& Handschuhe )

verwendet hast? Damit habe ich noch gar net gearbeitet

Wenn du call-by-reference noch nicht hattest, dann mach es erstmal so:

void H_Handschuh( std::vector<Gegenstand> Handschuhe )

xStrykex schrieb:

Problem dabei ist, bzw ebenso eine Frage, dass es eine Konstante sein muss und keine Variable. Kann man da irgendwie tricksen?

Verstehe ich immer noch nicht. Konstante?

xStrykex schrieb:

Mir fällt grade auf, dass in meinem Buch (bisher) immer beides eingebunden wurde:

#include<vector> // Standard-Vektor bekannt machen
#include<cstddef> // size_t

Beides einzubinden ist schon korrekt. Ich persönlich benutze aber kein size_t , darum binde ich cstddef nicht ein.

xStrykex schrieb:

Problem dabei ist, bzw ebenso eine Frage, dass es eine Konstante sein muss und keine Variable. Kann man da irgendwie tricksen?

Verstehe ich immer noch nicht. Konstante?

int i = 0; // muss laut Fehler const sein
Werkzeug alle_Werkzeuge[i]; // i statt 2--> Fehler, da i > 0 sein muss & konstant

	Werkzeug Hammer;
	Hammer.attribute.Nummer = 1;
	Hammer.attribute.Name = "Hammer";
	Hammer.attribute.Wert = 9.99;
	sizeof(alle_Werkzeuge++) = Hammer; // Fehler, da keine Variable erlaubt
                                         // bei int i = 1

	W_Werkzeug(alle_Werkzeuge);

um die Globalen HAnzahl & WAnzahl wegstreichen zu können

out schrieb:

Ich persönlich benutze aber kein size_t , darum binde ich cstddef nicht ein.

Bedeutet, dass size_t eigentlich irrelevant ist, da man durch Vektoren o.ä. Selbiges erreichen kann? Hoffe habe das so richtig verstanden.

int i = 0; // muss laut Fehler const sein
Werkzeug alle_Werkzeuge[i]; // i statt 2--> Fehler, da i > 0 sein muss & konstant

	Werkzeug Hammer;
	Hammer.attribute.Nummer = 1;
	Hammer.attribute.Name = "Hammer";
	Hammer.attribute.Wert = 9.99;
	sizeof(alle_Werkzeuge++) = Hammer; // Fehler, da keine Variable erlaubt
                                         // bei int i = 1

	W_Werkzeug(alle_Werkzeuge);

um die Globalen HAnzahl & WAnzahl wegstreichen zu können

Richtig. Bei nicht-dynamischen Arrays muss die Größe eine Konstante sein. Wenn die Größe variabel sein soll, brauchst du ein dynamisches Array. In C++ ist ein dynamisches Array std::vector . (Wie std::vector verwendet wird, hat mein Beispiel vorhin gezeigt.)

xStrykex schrieb:

Bedeutet, dass size_t eigentlich irrelevant ist, da man durch Vektoren o.ä. Selbiges erreichen kann? Hoffe habe das so richtig verstanden.

Nein, für die Standardbibliothek ist size_t nicht irrelevant und viele Entwickler nutzen es auch in ihrem Code. size_t ist nur ein Aliasname für irgendeinen unsigned integralen Datentyp, bei mir ist z.B. size_t == unsigned int . size_t ist jedoch nicht der einzige Aliasname für einen unsigned integralen Datentyp, da gibts z.B. auch noch size_type . Ich persönlich finde es doof, dass es so viele Aliasnamen für irgendwelche Typen gibt, darum verwende ich schlicht unsigned für nicht-negative Ganzzahlen und int für negative Ganzzahlen.

#include<iostream>
#include<string>

using namespace std;

struct Attribute // habe ich erstmal zurückgesetzt zum besseren Verständnis für mich :)
{
	string Name;
	double Wert;
	int Nummer;
};

struct Handschuh
{
	Attribute attribute;
};

struct Werkzeug
{
	Attribute attribute;
};
void W_Werkzeug(Werkzeug *w, int WAnzahl)
{
	cout << endl << endl << "Folgende Werkzeuge " << WAnzahl << " Sind in der Datenbank:" << endl;
	for (int i=0; i<WAnzahl; i++)
	{
		cout << "Werzeug Nummer: " << w[i].attribute.Nummer << endl;
		cout << "Werzeug Name: " << w[i].attribute.Name << endl;
		cout << "Werzeug Wert: " << w[i].attribute.Wert << " Euro" << endl << endl;
	}
};
int main()
{
	int WAnzahl = 0;
	Werkzeug alle_Werkzeuge[2];

	Werkzeug Hammer;
	Hammer.attribute.Nummer = 1;
	Hammer.attribute.Name = "Hammer";
	Hammer.attribute.Wert = 9.99;
	alle_Werkzeuge[WAnzahl++] = Hammer;

	Werkzeug Zange;
	Zange.attribute.Nummer = 2;
	Zange.attribute.Name = "Zange";
	Zange.attribute.Wert = 4.99;
	alle_Werkzeuge[WAnzahl++] = Zange;

	W_Werkzeug(alle_Werkzeuge, WAnzahl);

	cin.get();
	return 0;
}

Hoffe es gefällt dir soweit
size_t werde ich ebenfalls vorerst weglassen, klingt für mich logisch was du gesagt hast und hast mich überzeugt
Werde jetzt die Vektoren nochmal genauer unter die Lupe nehmen.
Dank dir

EDIT: In deinem früheren Post, was hat das push.back bewerkstelligt? Ich kenne es nur im Zusammenahng mit einer Funktion, bei der ein Wert über die Tastatur eingelesen wird, bis eine Matrix voll ist. (in while schleife war das, wenn ich mich Recht entsinne)

Ich weiß wofür \n steht, aber ich kann es nicht nutzen--> Fehlermeldung: Unbekanntes Token

globale Konstanten

globale Variablen meinte ich natürlich.

Etwas unglücklich: hatte in meinem Beitrag während deines Posts etwas editiert, ach ich poste es einfach nochmal

xStrykex schrieb:

EDIT: In deinem früheren Post, was hat das push.back bewerkstelligt? Ich kenne es nur im Zusammenahng mit einer Funktion, bei der ein Wert über die Tastatur eingelesen wird, bis eine Matrix voll ist. (in while schleife war das, wenn ich mich Recht entsinne)

Ich weiß wofür \n steht, aber ich kann es nicht nutzen--> Fehlermeldung: Unbekanntes Token

UML-Balzert-1999-Lehrbuch der Objektmodellierung

Kenn ich nicht.

xStrykex schrieb:

Prog C++Breymann-2011-Der C++ Programierer

Gute Wahl.

xStrykex schrieb:

was hat das push.back bewerkstelligt?

Diese Elementfunktion fügt eine Kopie des übergebenen Elements am Ende des vector s ein. Machst du z.B.

vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);

dann ist der Inhalt des Containers anschließend |1|2|3|.

xStrykex schrieb:

Ich weiß wofür \n steht, aber ich kann es nicht nutzen--> Fehlermeldung: Unbekanntes Token

Es heißt auch '\n' und nicht \n . Das macht einfach nur eine neue Zeile.

xStrykex schrieb:

Prog C++Breymann-2011-Der C++ Programierer

Gute Wahl.

Ich finde es auch ziemlich gut, sehr einfach zu lesen/verstehen.

out schrieb:

xStrykex schrieb:

Ich weiß wofür \n steht, aber ich kann es nicht nutzen--> Fehlermeldung: Unbekanntes Token

Es heißt auch '\n' und nicht \n . Das macht einfach nur eine neue Zeile.

Und ich hab mich schon immer gewundert

Habe jetzt nur noch ein Problem mit dem push_back und keine Ahnung was
Habe mich jetzt strikt nach deinem Beispiel gerichtet.

#include<iostream>
#include<string>
#include<vector>

using namespace std;

struct Ausruestung
{
	string Name;
	double Wert;
	int Nummer;
};
void W_Werkzeug(vector<Ausruestung>Werkzeug, int WAnzahl)
{
	cout << endl << endl << "Folgende Werkzeuge " << WAnzahl << " Sind in der Datenbank:" << endl;
	for (int i=0; i<WAnzahl; i++)
	{
		cout << "Werzeug Nummer: " << Werkzeug[i].Nummer << endl;
		cout << "Werzeug Name: " << Werkzeug[i].Name << endl;
		cout << "Werzeug Wert: " << Werkzeug[i].Wert << " Euro" << endl << endl;
	}
};
int main()
{
	int WAnzahl = 0;

	vector<Ausruestung>werkzeug;

	Ausruestung Werkzeug_Hammer;
	Werkzeug_Hammer.Nummer = 1;
	Werkzeug_Hammer.Name = "Hammer";
	Werkzeug_Hammer.Wert = 9.99;
	werkzeug[WAnzahl++] = Werkzeug_Hammer;
	werkzeug.push_back( Werkzeug_Hammer );

	Ausruestung Werkzeug_Zange;
	Werkzeug_Zange.Nummer = 2;
	Werkzeug_Zange.Name = "Zange";
	Werkzeug_Zange.Wert = 4.99;
	werkzeug[WAnzahl++] = Werkzeug_Zange;
	werkzeug.push_back( Werkzeug_Zange );

	W_Werkzeug(werkzeug, WAnzahl);

	cin.get();
	return 0;
}

Er gibt drei Fehlermeldungen in einem neuen Fenster, was ich noch nie hatte.
-dbghook.c
-vector
-stdthrow
+ deren Code, wodurch ich aber nichts erfahre

PS: habe erstmal mit Absicht wieder namespace benutzt, nutze lieber endl statt '\n' Wäre so viel Schreibarbeit

EDIT:
1.Debug Assertion Failed - vector subscript out of range
2.Debug Assertion Failed - Standard C++ Libraries out of range
3. waren doch nur 2 anscheinend

xStrykex schrieb:

PS: habe erstmal mit Absicht wieder namespace benutzt, nutze lieber endl statt '\n' Wäre so viel Schreibarbeit

http://www.c-plusplus.net/forum/308808-full?highlight=flush

werkzeug[WAnzahl++] = Werkzeug_Zange; // Mit [] greifst du auf ein Element des vectors zu. Dieses Element gibt es aber noch nicht...
	werkzeug.push_back( Werkzeug_Zange ); // ...es wird ja erst hier eingefügt. Und da du nur einfügen willst, lass die obere Zeile weg.

	W_Werkzeug(werkzeug, WAnzahl);
}

Wenn ich die obere Zeile weggelassen habe, kam zwar eine Ausgabe, aber lediglich wie

Folgende Handschuhe 0 sind in der Datenbank:

Folgende Werkzeuge 0 sind in der Datenbank:

EDIT: Habe die beiden Zeilen anschließend einfach nur getauscht und zapzarap es geht.
Dennoch Danke

Dir zu Ehren nutze ich jetzt '\n'

#include<iostream>
#include<string>
#include<vector>

struct Attribute
{
	std::string Name;
};
void H_Haende(std::vector<Attribute> Haende, int HAnzahl)
{
	std::cout << "Diese Handschuhe befinden sich im Speicher:" << '\n';
	for(int i=0; i<	HAnzahl; i++)
	{
		std::cout << Haende[i].Name << '\n';
	}
}
int main()
{
	std::vector<Attribute> haende;
	int HAnzahl = 0;
	Attribute S_Haende;
	S_Haende.Name = "Stoffhandschuh";
	haende.push_back(S_Haende);
	haende[HAnzahl++]=S_Haende;
	Attribute X_Haende;
	std::string x;
	std::cin >> x;
	X_Haende.Name=x;
	haende.push_back(X_Haende);
	haende[HAnzahl++]=X_Haende;

	H_Haende (haende, HAnzahl);

	std::cin.get();
	return 0;
}

EDIT: Muss ich eine zweite Funktion extra dafür schreiben?