Mal wieder Lagerverwaltung

NukE

@Swordfish
vector darf ich da noch nicht verwenden

@NukE sagte in Mal wieder Lagerverwaltung:

@Wade1234
Okay danke schonmal für die Antwort.
Kannst du mir einen Tipp geben wie ich auf die anderen Kisten dann zugreifen kann?

Mit einem i ungleich 0. Möglicherweise soll das ja aus der Antwort auf cout << "Welche Kiste soll eingepflegt werden?: "; bestimmt werden.

NukE

@manni66
Ich glaube das hab ich falsch verstanden, aber meinst du so?

if(((aKiste[i].nummer<50)&&(aKiste[i].aktiv!=1)&&(aKiste[i].nummer!=0)))

nein er (und ich auch) meint, dass du "cin >> i" schreiben und daraus folgend das element "nummer" aus der struktur entfernen, sowie weitere anpassungen vornehmen solltest.

NukE

@Wade1234
Ahh ja jetzt hab ich es danke

NukE

Ich bins nochmal...

Also soweit läuft alles wie gewollt. Danke nochmal für die Tipps.
Allerdings habe ich nun das Problem, dass ich zwar bei (5) alle Kisten angezeigt bekomme, allerdings sieht er die erste Kiste als 2 und die 49. Kiste als 50.. Ich weis das dass Array[50] von 0-49 geht. Wie kann ich das ändern?

#include <iostream>
using namespace std;

struct Lager
{
    int nummer;
    double breite;
    double laenge;
    double hoehe;
    double volumen;
    int aktiv=0;
}aKiste;

Lager eingeben(Lager aKiste[50])
{
    int i=0;
    cout << "Welche Kiste soll eingepflegt werden?: ";
    cin >> i;

    if(((i<50)&&(i!=0)&&(aKiste[i].aktiv!=1)))
    {
        cout << "hoehe der " << i << " Kiste: ";
        cin >> aKiste[i].hoehe;
        cout << "breite der " << i << " Kiste: ";
        cin >> aKiste[i].breite;
        cout << "laenge der " << i << " Kiste: ";
        cin >> aKiste[i].laenge;
        aKiste[i].aktiv=1;
        aKiste[i].volumen=aKiste[i].hoehe*aKiste[i].breite*aKiste[i].laenge;
        cout << '\n';
    }
    else if(i>=50)
    {
        cout << "Max. 50 Kisten erlaubt!\n";
    }
    else
    {
        cout << "Kiste bereits belegt!\n";
    }
   return aKiste[i];
}

Lager einzelAuflisten(Lager aKiste[50])
{
    int i=0;
    cout << "Welche Kiste soll angezeigt werden?: ";
    cin >> i;

    if((aKiste[i].nummer <50) && (aKiste[i].aktiv==1))
    {
        cout << "Kiste Nr.:\t " << aKiste[i].nummer << '\n';
        cout << "Volumen: \t" << aKiste[i].volumen << '\n';
        cout << "Aktiv: \t\t" << aKiste[i].aktiv << '\n';
    }
    else if((aKiste[i].nummer <50) && (aKiste[i].aktiv!=1))
    {
        cout << "Kiste nr.: \t" << aKiste[i].nummer << " nicht belegt!\n";
    }
    else cout << "Falsche eingabe? (max. 50!)\n";

    return aKiste[i];
}

Lager aendern(Lager aKiste[50])
{
    int i=0;

    cout << "Bitte geben Sie die Nummer der Kiste ein die Sie aendern wollen: ";
    cin >> i;

    if((i<50)&&(aKiste[i].aktiv==1))
    {
        cout << "hoehe der " << i << " Kiste: ";
        cin >> aKiste[i].hoehe;
        cout << "breite der " << i << " Kiste: ";
        cin >> aKiste[i].breite;
        cout << "laenge der " << i << " Kiste: ";
        cin >> aKiste[i].laenge;
        aKiste[i].aktiv=1;
        aKiste[i].volumen=aKiste[i].hoehe*aKiste[i].breite*aKiste[i].laenge;
        cout << '\n';
    }
    else if(i>=50)
    {
        cout << "Max 50 Kisten!\n";
    }
return aKiste[i];
}

Lager loeschen(Lager aKiste[50])
{
    int i=0;

    cout << "Bitte geben Sie die Nummer der zu loeschenden Kiste ein: ";
    cin >> i;
    if ((i<50)&&(aKiste[i].aktiv==1))
    {
        aKiste[i].aktiv=0;
        cout << '\n';
        cout << "Kiste nr.: " << i << " wurde geloescht!\n";
    }
return aKiste[i];
}


Lager alleAuflisten(Lager alleKisten[50])
{
    cout <<"Kistennr.:\tVolumen:\tAktiv:\n";
    for (int i=0;i<50;i++)
    {
    cout  << alleKisten[i].nummer << "\t\t" << alleKisten[i].volumen << "\t\t" << alleKisten[i].aktiv <<'\n';
    }
    return alleKisten[50];
}



int main()
{
   Lager alleKisten[50];
   int auswahl;

   for(int i=0;i<50;i++)
           {
               alleKisten[i].volumen=0;
               alleKisten[i].aktiv=0;
               alleKisten[i].nummer=i+1;
           }

   do
   {
       cout << "Kistenlager\n";
       cout << '\n';
       cout << "(1) Kiste anlegen\n";
       cout << "(2) Kiste anzeigen\n";
       cout << "(3) Kiste aendern\n";
       cout << "(4) Kiste loeschen\n";
       cout << "(5) Alle Kisten anzeigen\n";
       cout << "(6) Programm beenden\n";
       cin >> auswahl;

       switch(auswahl)
       {
       case 1:
           eingeben(alleKisten);
           break;
       case 2:
           einzelAuflisten(alleKisten);
           break;
       case 3:
           aendern(alleKisten);
           break;
       case 4:
           loeschen(alleKisten);
           break;
       case 5:
           alleAuflisten(alleKisten);
           break;
       case 6:
           cout << "Die Lagerverwaltung wird beendet.";
           exit(0);
       }

   }while (auswahl !=6);


    return 0;
}

Swordfish

@NukE sagte in Mal wieder Lagerverwaltung:

Allerdings habe ich nun das Problem, dass ich zwar bei (5) alle Kisten angezeigt bekomme, allerdings sieht er die erste Kiste als 2 und die 49. Kiste als 50..

Ist nicht nachvollziehbar.

Ausgabe:

Kistenlager

(1) Kiste anlegen
(2) Kiste anzeigen
(3) Kiste aendern
(4) Kiste loeschen
(5) Alle Kisten anzeigen
(6) Programm beenden
5
Kistennr.:      Volumen:        Aktiv:
1               0               0
2               0               0
3               0               0
4               0               0
5               0               0
6               0               0
7               0               0
8               0               0
9               0               0
10              0               0
11              0               0
12              0               0
13              0               0
14              0               0
15              0               0
16              0               0
17              0               0
18              0               0
19              0               0
20              0               0
21              0               0
22              0               0
23              0               0
24              0               0
25              0               0
26              0               0
27              0               0
28              0               0
29              0               0
30              0               0
31              0               0
32              0               0
33              0               0
34              0               0
35              0               0
36              0               0
37              0               0
38              0               0
39              0               0
40              0               0
41              0               0
42              0               0
43              0               0
44              0               0
45              0               0
46              0               0
47              0               0
48              0               0
49              0               0
50              0               0
Kistenlager

(1) Kiste anlegen
(2) Kiste anzeigen
(3) Kiste aendern
(4) Kiste loeschen
(5) Alle Kisten anzeigen
(6) Programm beenden

alleKisten[0].nummer == 1,
alleKisten[49].nummer == 50.

Über das (aKiste[i].nummer <50) in

@NukE sagte in Mal wieder Lagerverwaltung:

Lager einzelAuflisten(Lager aKiste[50])
{
    int i=0;
    cout << "Welche Kiste soll angezeigt werden?: ";
    cin >> i;

    if((aKiste[i].nummer <50) && (aKiste[i].aktiv==1))
    {
        cout << "Kiste Nr.:\t " << aKiste[i].nummer << '\n';
        cout << "Volumen: \t" << aKiste[i].volumen << '\n';
        cout << "Aktiv: \t\t" << aKiste[i].aktiv << '\n';
    }
    else if((aKiste[i].nummer <50) && (aKiste[i].aktiv!=1))
    {
        cout << "Kiste nr.: \t" << aKiste[i].nummer << " nicht belegt!\n";
    }
    else cout << "Falsche eingabe? (max. 50!)\n";

    return aKiste[i];
}

sollstest Du aber nochmal nachdenken. Wenn der User für i etwas > 49 eingibt hast Du ein Problem (Undefined Behaviour).

Aja, und warum gibst Du eine Kopie von aKiste[i] zurück? ... und das auch noch in jedem Fall, egal was der Benutzer eingegeben hat?

Aja, und warum gibst Du eine Kopie von aKiste[i] zurück?

... das gilt auch für andere Funktionen. return alleKisten[50]; zB geht garnicht. Undefined Behaviour.

Du must Dich mal entscheiden, ob der Benutzer ein i eingeben lässt, daß Du dann (unabhängig von der "nummer" der Kiste) als Arrayindex nimmst, oder ob Du in aKiste[0...49] nach einer Kiste mit der vom Benutzer eingegebenen "nummer" suchen willst.

PS: Warum heißt eine Kiste eigentlich Lager?

PPS: Was soll diese globale Variable aKiste

@NukE sagte in Mal wieder Lagerverwaltung:

struct Lager
{
    int nummer;
    double breite;
    double laenge;
    double hoehe;
    double volumen;
    int aktiv=0;
}aKiste;   // <<----------- HIER

?

PPS: Gegenvorschlag

#include <cstddef>  // std::size_t
#include <cstdlib>  // EXIT_SUCCESS
#include <iostream>

// using namespace std;  // Totsuende

struct Kiste
{
	double  breite   = 0.;
	double  laenge   = 0.;
	double  hoehe    = 0.;
	double  volumen  = 0.;
	bool    aktiv    = false;
};

struct Lager
{
	static constexpr std::size_t anzahl_kisten = 50;
	Kiste kisten[anzahl_kisten];
};

bool eingeben(Lager &lager)
{
	std::cout << "Welche Kiste soll eingepflegt werden (1 ... << " << Lager::anzahl_kisten << ") ? ";
	std::size_t nummer;
	std::cin >> nummer;

	if (nummer < 1 || Lager::anzahl_kisten < nummer) {
		std::cerr << "Max. " << Lager::anzahl_kisten << " Kisten erlaubt!\n";
		return false;
	}

	std::size_t i = nummer - 1;

	if (lager.kisten[i].aktiv) {
		std::cerr << "Kiste #" << nummer << " ist bereits belegt!\n";
		return false;
	}

	std::cout << "Hoehe der Kiste #" << nummer << ": ";
	std::cin >> lager.kisten[i].hoehe;
	std::cout << "Breite der Kiste #" << nummer << ": ";
	std::cin >> lager.kisten[i].breite;
	std::cout << "Laenge der Kiste #" << nummer << ": ";
	std::cin >> lager.kisten[i].laenge;
	lager.kisten[i].volumen = lager.kisten[i].hoehe * lager.kisten[i].breite * lager.kisten[i].laenge;
	lager.kisten[i].aktiv = true;

	return true;
}

bool einzelAuflisten(Lager const &lager)
{
	std::cout << "Welche Kiste soll angezeigt werden (1 ... << " << Lager::anzahl_kisten << ") ? ";
	std::size_t nummer;
	std::cin >> nummer;

	if (nummer < 1 || Lager::anzahl_kisten < nummer) {
		std::cerr << "Max. " << Lager::anzahl_kisten << " Kisten erlaubt!\n";
		return false;
	}

	std::size_t i = nummer - 1;

	if (!lager.kisten[i].aktiv) {
		std::cerr << "Kiste #" << nummer << " ist nicht belegt!\n";
		return false;
	}

	std::cout << "Kiste # " << nummer << ":\n"
	             "Volumen: " << lager.kisten[i].volumen  << "\n"
	             "l, b, h: " << lager.kisten[i].laenge   << ", "
	                         << lager.kisten[i].breite   << ", "
	                         << lager.kisten[i].hoehe    << '\n';
	return true;
}

bool aendern(Lager &lager)
{
	std::cout << "Welche Kiste soll geaendert werden (1 ... << " << Lager::anzahl_kisten << ") ? ";
	std::size_t nummer;
	std::cin >> nummer;

	if (nummer < 1 || Lager::anzahl_kisten < nummer) {
		std::cerr << "Max. " << Lager::anzahl_kisten << " Kisten erlaubt!\n";
		return false;
	}

	std::size_t i = nummer - 1;

	if (!lager.kisten[i].aktiv) {
		std::cerr << "Kiste #" << nummer << " ist nicht belegt!\n";
		return false;
	}

	std::cout << "Hoehe der Kiste #" << nummer << ": ";
	std::cin >> lager.kisten[i].hoehe;
	std::cout << "Breite der Kiste #" << nummer << ": ";
	std::cin >> lager.kisten[i].breite;
	std::cout << "Laenge der Kiste #" << nummer << ": ";
	std::cin >> lager.kisten[i].laenge;
	lager.kisten[i].volumen = lager.kisten[i].hoehe * lager.kisten[i].breite * lager.kisten[i].laenge;
	lager.kisten[i].aktiv = true;

	return true;
}

bool loeschen(Lager &lager)
{
	std::cout << "Welche Kiste soll geloescht werden (1 ... << " << Lager::anzahl_kisten << ") ? ";
	std::size_t nummer;
	std::cin >> nummer;

	if (nummer < 1 || Lager::anzahl_kisten < nummer) {
		std::cerr << "Max. " << Lager::anzahl_kisten << " Kisten erlaubt!\n";
		return false;
	}

	std::size_t i = nummer - 1;

	if (!lager.kisten[i].aktiv) {
		std::cerr << "Kiste #" << nummer << " ist nicht belegt!\n";
		return false;
	}

	lager.kisten[i].aktiv = false;
	std::cout << "Kiste # " << nummer << " wurde geloescht!\n";
	return true;
}

void alleAuflisten(Lager const &lager)
{
	std::cout << "Kiste #\tVolumen\tAktiv\n";
	for (std::size_t i = 0; i < Lager::anzahl_kisten; ++i)
		std::cout << i + 1 << "\t\t" << lager.kisten[i].volumen << "\t\t" << lager.kisten[i].aktiv << '\n';
}

int main()
{
	Lager mein_lager;
	int auswahl = 0;

	do {
		std::cout << "Kistenlager\n\n"
		             "(1) Kiste anlegen\n"
		             "(2) Kiste anzeigen\n"
		             "(3) Kiste aendern\n"
		             "(4) Kiste loeschen\n"
		             "(5) Alle Kisten anzeigen\n"
		             "(6) Programm beenden\n";
		std::cin >> auswahl;

		switch (auswahl)
		{
		case 1:
			eingeben(mein_lager);
			break;
		case 2:
			einzelAuflisten(mein_lager);
			break;
		case 3:
			aendern(mein_lager);
			break;
		case 4:
			loeschen(mein_lager);
			break;
		case 5:
			alleAuflisten(mein_lager);
			break;
		case 6:
			std::cout << "Die Lagerverwaltung wird beendet.";
			return EXIT_SUCCESS;  // oder von mir aus 0
		}

	} while (auswahl != 6);

	// return 0;   // ueberfluessig
}

Aber jetzt sieht man, daß da viel Code doppelt und dreifach ist, also restrukturieren:

#include <cstddef>  // std::size_t
#include <cstdlib>  // EXIT_SUCCESS
#include <iostream>

// using namespace std;  // Totsuende

struct Kiste
{
	double  breite   = 0.;
	double  laenge   = 0.;
	double  hoehe    = 0.;
	double  volumen  = 0.;
	bool    aktiv    = false;
};

struct Lager
{
	static constexpr std::size_t anzahl_kisten = 50;
	Kiste kisten[anzahl_kisten];
};

std::size_t kisteAuswaehlen(Lager const &lager, char const *verb, bool muss_aktiv_sein = false)
{
	std::cout << "Welche Kiste soll " << verb << " werden (1 ... << " << Lager::anzahl_kisten << ") ? ";
	std::size_t nummer;
	std::cin >> nummer;

	if (nummer < 1 || Lager::anzahl_kisten < nummer) {
		std::cerr << "Max. " << Lager::anzahl_kisten << " Kisten erlaubt!\n";
		return 0;
	}

	if (muss_aktiv_sein && !lager.kisten[nummer - 1].aktiv) {
		std::cerr << "Kiste #" << nummer << " ist nicht belegt!\n";
		return 0;
	}
	
	return nummer;
}

Kiste kisteEinlesen(std::size_t nummer)
{
	Kiste neue_kiste;
	std::cout << "Hoehe der Kiste #" << nummer << ": ";
	std::cin >> neue_kiste.hoehe;
	std::cout << "Breite der Kiste #" << nummer << ": ";
	std::cin >> neue_kiste.breite;
	std::cout << "Laenge der Kiste #" << nummer << ": ";
	std::cin >> neue_kiste.laenge;
	neue_kiste.volumen = neue_kiste.hoehe * neue_kiste.breite * neue_kiste.laenge;
	neue_kiste.aktiv = true;
	return neue_kiste;
}

bool eingeben(Lager &lager, std::size_t nummer)
{
	if (!nummer) return false;

	--nummer;
	if (lager.kisten[nummer].aktiv) {
		std::cerr << "Kiste #" << nummer << " ist bereits belegt!\n";
		return false;
	}

	lager.kisten[nummer] = kisteEinlesen(nummer);
	return true;
}

bool einzelAuflisten(Lager const &lager, std::size_t nummer)
{
	if (!nummer) return false;

	--nummer;
	std::cout << "Kiste # " << nummer << ":\n"
	             "Volumen: " << lager.kisten[nummer].volumen  << "\n"
	             "l, b, h: " << lager.kisten[nummer].laenge   << ", "
	                         << lager.kisten[nummer].breite   << ", "
	                         << lager.kisten[nummer].hoehe    << '\n';
	return true;
}

bool aendern(Lager &lager, std::size_t nummer)
{
	if (!nummer) return false;

	lager.kisten[nummer - 1] = kisteEinlesen(nummer);
	return true;
}

bool loeschen(Lager &lager, std::size_t nummer)
{
	if (!nummer) return false;

	lager.kisten[nummer - 1].aktiv = false;
	std::cout << "Kiste # " << nummer << " wurde geloescht!\n";
	return true;
}

void alleAuflisten(Lager const &lager)
{
	std::cout << "Kiste #\tVolumen\tAktiv\n";
	for (std::size_t i = 0; i < Lager::anzahl_kisten; ++i)
		std::cout << i + 1 << "\t\t" << lager.kisten[i].volumen << "\t\t" << lager.kisten[i].aktiv << '\n';
}

int main()
{
	Lager mein_lager;
	int auswahl = 0;

	do {
		std::cout << "Kistenlager\n\n"
		             "(1) Kiste anlegen\n"
		             "(2) Kiste anzeigen\n"
		             "(3) Kiste aendern\n"
		             "(4) Kiste loeschen\n"
		             "(5) Alle Kisten anzeigen\n"
		             "(6) Programm beenden\n";

		std::cin >> auswahl;

		switch (auswahl)
		{
		case 1:
			eingeben(mein_lager, kisteAuswaehlen(mein_lager, "eingepflegt"));
			break;
		case 2:
			einzelAuflisten(mein_lager, kisteAuswaehlen(mein_lager, "angezeigt", true));
			break;
		case 3:
			aendern(mein_lager, kisteAuswaehlen(mein_lager, "geaendert", true));
			break;
		case 4:
			loeschen(mein_lager, kisteAuswaehlen(mein_lager, "geloescht", true));
			break;
		case 5:
			alleAuflisten(mein_lager);
			break;
		}

	} while (auswahl != 6);

	std::cout << "Die Lagerverwaltung wird beendet.";
	return EXIT_SUCCESS;  // oder von mir aus 0
}

Und weil es jetzt schon wie objektorientiertes C aussieht, machen wir objektorientiertes C++ daraus:

#include <cstddef>  // std::size_t
#include <cstdlib>  // EXIT_SUCCESS
#include <iostream>

struct Kiste
{
	double  breite   = 0.;
	double  laenge   = 0.;
	double  hoehe    = 0.;
	double  volumen  = 0.;
	bool    aktiv    = false;
};

struct Lager
{
	static constexpr std::size_t anzahl_kisten = 50;
	Kiste kisten[anzahl_kisten];

	std::size_t kisteAuswaehlen(char const *verb, bool muss_aktiv_sein = true) const
	{
		std::cout << "Welche Kiste soll " << verb << " werden (1 ... << " << Lager::anzahl_kisten << ") ? ";
		std::size_t nummer;
		std::cin >> nummer;

		if (nummer < 1 || Lager::anzahl_kisten < nummer) {
			std::cerr << "Max. " << Lager::anzahl_kisten << " Kisten erlaubt!\n";
			return 0;
		}

		if (muss_aktiv_sein && !kisten[nummer - 1].aktiv) {
			std::cerr << "Kiste #" << nummer << " ist nicht belegt!\n";
			return 0;
		}

		return nummer;
	}

	void kisteEinlesen(std::size_t nummer)
	{
		std::cout << "Hoehe der Kiste #" << nummer << ": ";
		std::cin >> kisten[nummer - 1].hoehe;
		std::cout << "Breite der Kiste #" << nummer << ": ";
		std::cin >> kisten[nummer - 1].breite;
		std::cout << "Laenge der Kiste #" << nummer << ": ";
		std::cin >> kisten[nummer - 1].laenge;
		kisten[nummer - 1].volumen = kisten[nummer - 1].hoehe * kisten[nummer - 1].breite * kisten[nummer - 1].laenge;
		kisten[nummer - 1].aktiv = true;
	}

	bool eingeben()
	{
		std::size_t nummer = kisteAuswaehlen("eingepflegt", false);
		if (!nummer) return false;

		if (kisten[nummer - 1].aktiv) {
			std::cerr << "Kiste #" << nummer << " ist bereits belegt!\n";
			return false;
		}

		kisteEinlesen(nummer);
		return true;
	}

	bool einzelAuflisten() const
	{
		std::size_t nummer = kisteAuswaehlen("angezeigt");
		if (!nummer) return false;

		--nummer;
		std::cout << "Kiste # " << nummer + 1 << ":\n"
		             "Volumen: " << kisten[nummer].volumen << "\n"
		             "l, b, h: " << kisten[nummer].laenge << ", "
		                         << kisten[nummer].breite << ", "
		                         << kisten[nummer].hoehe << '\n';
		return true;
	}

	bool aendern()
	{
		std::size_t nummer = kisteAuswaehlen("geaendert");
		if (!nummer) return false;
		
		kisteEinlesen(nummer);
		return true;
	}

	bool loeschen()
	{
		std::size_t nummer = kisteAuswaehlen("geloescht");
		if (!nummer) return false;

		kisten[nummer - 1].aktiv = false;
		std::cout << "Kiste # " << nummer << " wurde geloescht!\n";
		return true;
	}

	void alleAuflisten() const
	{
		std::cout << "Kiste #\tVolumen\tAktiv\n";
		for (std::size_t i = 0; i < Lager::anzahl_kisten; ++i)
			std::cout << i + 1 << "\t\t" << kisten[i].volumen << "\t\t" << kisten[i].aktiv << '\n';
	}
};

int main()
{
	Lager mein_lager;
	int auswahl = 0;

	do {
		std::cout << "Kistenlager\n\n"
		             "(1) Kiste anlegen\n"
		             "(2) Kiste anzeigen\n"
		             "(3) Kiste aendern\n"
		             "(4) Kiste loeschen\n"
		             "(5) Alle Kisten anzeigen\n"
		             "(6) Programm beenden\n";

		std::cin >> auswahl;

		switch (auswahl)
		{
		case 1:
			mein_lager.eingeben();
			break;
		case 2:
			mein_lager.einzelAuflisten();
			break;
		case 3:
			mein_lager.aendern();
			break;
		case 4:
			mein_lager.loeschen();
			break;
		case 5:
			mein_lager.alleAuflisten();
			break;
		}

	} while (auswahl != 6);

	std::cout << "Die Lagerverwaltung wird beendet.";
	return EXIT_SUCCESS;  // oder von mir aus 0
}

NukE

@Swordfish
Hi und danke für die ausführliche Antwort
Ich habe es hinbekommen :D.
Das Problem ist nunmal das ich C++ per Fernstudium mache und nur im Code das verwenden darf was ich bis jetzt dran hatte.

NukE

// using namespace std; // Totsuende
Warum Totsünde?

Swordfish

@NukE Weil Du damit alles aus dem Namensraum std in den globalen Namensraum bringst. Das macht man nicht weil es dadurch zu Kollisionen kommen kann. Vor allem, Du verwendest sowieso nur zwei Dingstis daraus und dafür würde

#include <iostream>

using std::cin;
using std::cout;

reichen.

Th69

Nur in (öffentlichen) Headerdateien sollte man using namespace ganz vermeiden, in Sourcedateien hat man ja bei Konflikten selber die Möglichkeit, diese zu beheben.
Aber die Lösung mittels explizitem 'using X' ist zu bevorzugen (diese Liste kann aber in komplexeren Codes ziemlich lang werden - und evtl. würde man diese dann in eine weitere (Header-)Datei auslagern ;-).