Fehler in Ausgabe [geloest]

[out]

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.

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]

out schrieb:

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.

[out]

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?

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

[xStrykex]

Mit dem

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

[out]

xStrykex schrieb:

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]

out schrieb:

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.

[out]

xStrykex schrieb:

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.

[xStrykex]

Ich habe es jetzt wie folgt geschrieben:

#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

[out]

Sieht fast so aus, wie bei deinem ersten Beitrag, nur ohne globale Konstanten und ohne den copy-paste-Fehler. Aber gut, der Rest ergibt sich dann, wenn du dein Buch weiter durcharbeitest. Wie heißt das Buch denn?

[out]

out schrieb:

globale Konstanten

globale Variablen meinte ich natürlich.

[xStrykex]

UML-Balzert-1999-Lehrbuch der Objektmodellierung
und
Prog C++Breymann-2011-Der C++ Programierer
parallel

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

[out]

xStrykex schrieb:

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]

out schrieb:

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

[out]

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?

[out]

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
}

[out]

Ich brauch erstmal deinen aktuellen Quellcode:D

[xStrykex]

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