Fehler in Ausgabe [geloest]

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);
}

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

xStrykex

out schrieb:

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'

xStrykex

So, eine erneute Frage:
Ich möchte zusätzlich Namen selber einlesen, soweit so gut, klappt alles.
Aaaaaber wie kann ich den Namen zum Ende hin, also nach der bisherigen Ausgabe, eingeben? (Momentan muss ich Namen vor der ganzen Ausgabe einlesen, welche aber nach der, ich sag mal, "geschriebenen" Ausgabe ausgegeben werden)

#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?

Ich verstehe nicht ganz. Meist du vielleicht das?

cin >> haende[0].Name;

xStrykex

Ah schon solange auf Dich und eine Antwort von Dir gewartet

Den bisherigen Code kennst du ja, nun möchte ich alles nach wie vor ausgeben, aber anschließend noch weitere member(?) eingeben. Aber ich muss x vor der Ausgabe eingeben, möchte das aber erst am Ende tun.

Momentaner Output ist

WerkzeugXY // Eingabe
Folgende Werkzeuge 3 sind in der Datenbank: //  :live: 
Werzeug Nummer: 1
Werzeug Name: Hammer
Werzeug Wert: 9.99 Euro

Werzeug Nummer: 1 //  :die: hier sollte 2 stehen
Werzeug Name: Hammer //  :die: hier sollte Zange stehen
Werzeug Wert: 9.99 Euro //  :die: hier sollte 4.99 Euro stehen

Werzeug Nummer: -858993460 // momentan irrelevant
Werzeug Name: WerkzeugXY
Werzeug Wert: -9.25596e+061 Euro // ebenfalls momentan irrelevant

Ich möchte aber:

Folgende Werkzeuge 3 sind in der Datenbank:
Werzeug Nummer: 1
Werzeug Name: Hammer
Werzeug Wert: 9.99 Euro

Werzeug Nummer: 2
Werzeug Name: Zange
Werzeug Wert: 4.99 Euro

WerkzeugXY // hier sollte die Eingabe stehen

Werzeug Nummer: -858993460
Werzeug Name: WerkzeugXY
Werzeug Wert: -9.25596e+061 Euro

Ein zusätzliches Problem ist, dass Hammer zweimal ausgegeben wird

EDIT: hier nochmal der Code (tut mir Leid, hatte vorher Beispiel von einem anderen Code aus Versehen genommen )

void W_Werkzeug(std::vector<Ausruestung>Werkzeug, int WAnzahl) // Funktion fuer Werkzeuge
{
	std::cout << '\n' << '\n' << "Folgende Werkzeuge " << WAnzahl << " sind in der Datenbank:" << '\n';
	for (int i=0; i<WAnzahl; i++) // nach und nach
	{
		std::cout << "Werzeug Nummer: " << Werkzeug[i].Nummer << '\n';
		std::cout << "Werzeug Name: " << Werkzeug[i].Name << '\n';
		std::cout << "Werzeug Wert: " << Werkzeug[i].Wert << " Euro" << '\n' << '\n';
	}
	std::cin.get();
};
int main()
{
int WAnzahl=0;
std::vector<Ausruestung>werkzeug;

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

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

	std::string x;
	std::cin >> x;
	Ausruestung Werkzeug_X;
	Werkzeug_X.Name = x;
	werkzeug.push_back( Werkzeug_X );
	werkzeug[WAnzahl++]=Werkzeug_X;

	W_Werkzeug(werkzeug, WAnzahl); // Rueckgabe
}

Ich brauch erstmal deinen aktuellen Quellcode:D

xStrykex

s.o.
include-Dateien etc erklären sich von selbst, ist ja nur Teil vom Code

void wait()
{
	std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ); // #include <limits>
	std::cin.get();
}

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

void W_Werkzeug(std::vector<Ausruestung> Werkzeug) // Funktion fuer Werkzeuge
{
	const unsigned WAnzahl = Werkzeug.size();
	std::cout << '\n' << '\n' << "Folgende Werkzeuge " << WAnzahl << " sind in der Datenbank:" << '\n';
    for (int i=0; i<WAnzahl; i++) // nach und nach
    {
        std::cout << "Werzeug Nummer: " << Werkzeug[i].Nummer << '\n';
        std::cout << "Werzeug Name: "   << Werkzeug[i].Name   << '\n';
        std::cout << "Werzeug Wert: "   << Werkzeug[i].Wert   << " Euro" << '\n' << '\n';
    }
    //std::cin.get(); // Ist dir noch nicht aufgefallen, dass das eigentlich nichts bringt.
	wait();
};

int main()
{
	std::vector<Ausruestung> werkzeug;

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

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

    Ausruestung Werkzeug_X;
    cin >> Werkzeug_X.Name;
    werkzeug.push_back( Werkzeug_X );

    W_Werkzeug(werkzeug); // Rueckgabe
}

Hab mal ein paar Dinge korrigiert.

xStrykex schrieb:

[...]nutze lieber endl statt '\n' Wäre so viel Schreibarbeit

Das ist nur bedingt ein guter Grund.

Guckst Du:

std::cout << "Werzeug Nummer: " << Werkzeug[i].Nummer;
        std::cout << "\nWerzeug Name: " << Werkzeug[i].Name;
        std::cout << "\nWerzeug Wert: " << Werkzeug[i].Wert << " Euro\n\n";

Oder sogar noch kürzer:

std::cout << "Werzeug Nummer: " << Werkzeug[i].Nummer
                  << "\nWerzeug Name: " << Werkzeug[i].Name
                  << "\nWerzeug Wert: " << Werkzeug[i].Wert << " Euro\n\n";

Oder kürzer und C++iger:

std::ostream& operator<<(std::ostream& os, const Ausruestung& a){
  os << "Werkzeug Nummer: " << a.Nummer
     << "\nWerkzeug Name: " << a.Name
     << "\nWerkzeug Wert: " << a.Wert << " Euro";
  return os;
}

void W_Werkzeug(vector<Ausruestung>Werkzeug, int WAnzahl)
{
  cout << "\n\nFolgende Werkzeuge " << WAnzahl << " Sind in der Datenbank:\n";
    for (int i=0; i<WAnzahl; i++)
    {
      cout << Werkzeug[i] << "\n\n";
    }
}

xStrykex

Also ich hatte das

cin.get();

am Ende der main, das hat nicht gereicht, habe ich es dort(Ausgabefunktion) reingepackt, hat es geklappt. Mit

wait();

klappt es gar nicht.
Jetzt hast mich doch zur ".size" bekommen

@Furble Wurble: Habe noch nicht mit Referenzen gearbeitet, hat out auch schon versucht

Ansonsten: Stimmt, net dran gedacht bzw gesehen

Ist es überhaupt irgendwann nötig endl zu benutzen? Ich hatte mir den Thread, den out gepostet hat, durchgelesen, aber habe dort nicht erfahren können, ob man endl überhaupt irgendwann benötigt.

Natürlich klappt wait , wieso sollte es nicht funktionieren? Also ich habe endl noch nie wirklich gebraucht.

xStrykex

out schrieb:

Natürlich klappt wait , wieso sollte es nicht funktionieren?

sry, bei mir klappts net, egal wieviele ich irgendwo hinsetze
Habe mal gelesen, dass manche Compiler manche Befehle wie wait(), cin.get(), getchar() nicht mehr annehmen würden. Habe anfangs getchar() benutzt. Hat anfangs geklappt und irgendwann nicht mehr, selbst dann nicht, wenn ich danach alles gelöscht und ein einfaches

int i=5;
int j=5;
cout << j+i;

z.B. eingegeben habe. Ist mir rätselhaft

out schrieb:

Also ich habe endl noch nie wirklich gebraucht.

Ok, mir würde spontan auch nix einfallen, aber bin auch noch Anfänger

Bist du sicher, dass du meine wait Funktion verwendest? Ansonsten kopier diese zwei Zeilen einfach an das Ende deiner Main-Funktion:

std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ); // #include <limits>
    std::cin.get();

Und funtioniert das:D ?

xStrykex

Ne, dann sind sogar die wait()´s nicht mehr definiert.
Habe schon die void wait(){...} abkopiert und nachgelesen.

Jetzt die *wait()*´s entfernt, aber immer noch dasselbe Problem.

Ist ja im Prinzip auch irrelevant, konnte fix abgucken und sehen, dass alles richtig ist
Aber kurios

Ich kann mir vorstellen, dass du sowas aus Versehen machst:

int main()
{
	std::string x; // Eingabe: hallo welt
	cin >> x;
	int wert;
	cin >> wert;

	std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ); // #include <limits>
    std::cin.get(); 
}

Sprich du gibst eine Zeichenkette ein, die ein Leerzeichen enthält, und danach willst du ein Zahl einlesen. Dann geht gehts wirklich nicht mehr. In dem Fall musst du diese 3 Zeilen benutzen:

std::cin.clear();
	std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ); // #include <limits>
    std::cin.get();

Damit wartest du mit Sicherheit.

xStrykex

Ok, jetzt funktioniert alles einwandfrei, danke

xStrykex

Ach, ich habe meinen Fehler entdeckt, habe die Daten in der falschen Reihenfolge eingelesen
jetzt klappts auch ohne das clear() etc

Gut, aber das clear schadet nicht. Ich habe in der wait Funktion immer alle drei Anweisungen drin stehen, damit es in jeder Situation funktioniert.

xStrykex

Ok, merk ich mir

Nun wollte ich eine while-Schleife einbauen:

Ausruestung Werkzeug_X;
	std::cout << "\n\nBei Eingabe \"0\" Abbruch\n";
	while (Werkzeug_X.Nummer != 0) // Wiederholungen solange Werkzeug_X.Nummer!= 0
	{
	std::cout << "\nGeben Sie die Nummer ein: \n";
	std::cin >> Werkzeug_X.Nummer;
	std::cout << "\nGeben Sie den Namen ein: \n";
	std::cin >> Werkzeug_X.Name;
	std::cout << "\nGeben Sie den Wert ein: \n";
	std::cin >> Werkzeug_X.Wert;
	werkzeug.push_back( Werkzeug_X );

	W_Werkzeug(werkzeug); // Rueckgabe
	}

Funktioniert soweit. Diesmal das Problem, dass bei 0 nicht abgebrochen wird, woran liegt das?

Da wird bei 0 schon abgebrochen. Wieso sollte es nicht abbrechen?