3. Variablen als Instanzname

Variablen als Instanzname

  • N

    Hi!

    Ich habe eine, für Euch wahrscheinlich ziemlich leicht zu lösende, Anfängerfrage.
    Und zwar möchte ich gerne eine Benutzereingabe in der der Benutzer 1, 2 oder 3 eingibt und dann die jeweiligen Attribute der Instanz über cout ausgegeben werden.

    Mein Code sieht bis jetzt so aus:

    int main() {
   char auswahl;
   Fahrzeug a(1, 70, 'c', 50, 'b');
   Fahrzeug b(1, 70, 'c', 50, 'b');
   Fahrzeug c(1, 70, 'c', 50, 'b');
   cout << "Welches Fahrzeug möchten Sie sehen? a, b oder c?" << endl;
   cin >> auswahl;
   cout << "Fahrzeugnummer:\t" << auswahl.fahrzeugNummer << endl;
   cout << "Leistung:\t" << auswahl.leistung << endl;
   cout << "Modell:\t" << auswahl.modell << endl;
   cout << "Tankinhalt:\t" << auswahl.tankInhalt << endl;
   cout << "Treibstoffart:\t" << auswahl.treibStoffArt << endl;
   getch();
}

    Vielen Dank schonmal für Eure Hilfe 😃

    0
  • E

    wie soll das gehen? wie sieht deine klasse aus?

    du hast doch 'auswahl' als 'char' deklariert! so geht das nicht, du kannst eine methode einer klasse auch NUR aus einer klasse heraus aufrufen.

    sprich klasse::methode => auswahl.suche();
    vorher mußt du natürlich ein objekt der klasse anlegen das die funktion aufruft

    0
  • L

    speicher die fahrzeuge in einem vektor....
    dann schreibst du noch eine funktion, die einen int wert erwartet(das ist die benutzereingabe)...
    diese funktion gibt dann die werte mittels cout << aus...

    bsp.:

    cout << VektorName[i-1].methode() << endl;   // [i-1], da man bei 0 anfängt zu zählen...
    0
  • ?

    Nilz_is_pro schrieb:

    Hi!

    Ich habe eine, für Euch wahrscheinlich ziemlich leicht zu lösende, Anfängerfrage.
    Und zwar möchte ich gerne eine Benutzereingabe in der der Benutzer 1, 2 oder 3 eingibt und dann die jeweiligen Attribute der Instanz über cout ausgegeben werden.

    Mein Code sieht bis jetzt so aus:

    int main() {
   char auswahl;
   Fahrzeug a(1, 70, 'c', 50, 'b');
   Fahrzeug b(1, 70, 'c', 50, 'b');
   Fahrzeug c(1, 70, 'c', 50, 'b');
   cout << "Welches Fahrzeug möchten Sie sehen? a, b oder c?" << endl;
   cin >> auswahl;
   cout << "Fahrzeugnummer:\t" << auswahl.fahrzeugNummer << endl;
   cout << "Leistung:\t" << auswahl.leistung << endl;
   cout << "Modell:\t" << auswahl.modell << endl;
   cout << "Tankinhalt:\t" << auswahl.tankInhalt << endl;
   cout << "Treibstoffart:\t" << auswahl.treibStoffArt << endl;
   getch();
}

    Vielen Dank schonmal für Eure Hilfe 😃

    So klappt das ganz bestimmt nicht, denn woher soll der Rechner denn jetzt wissen, dass die Benutzereingabe etwas mit Deinen Fahrzeugobjekten a,b und c zu tun hat?
    Eine einfache Möglichkeit wäre, dass Du deine drei Fahrzeuge in ein Array steckst:

    Fahrzeug** NFahrzeug; // 'Neues Fahrzeug'

NFahrzeug=new Fahrzeug* [3];

NFahrzeug[0] = new Fahrzeug;
NFahrzeug[1] = new Fahrzeug;
NFahrzeug[2] = new Fahrzeug; // Wieso sind eigentlich alle
                            // drei Fahrzeuge gleich?

// Dann kannst Du den Konstruktor explizit aufrufen:
for(int i=0;i<3;i++)
 NFahrzeug[i]->Fahrzeug(1,70,'c',50,'b');

// und wenn schließlich der Benutzer mit ...
cin >> Von_Dir_Definierte_Ganzzahlvariable;

#define VDDG Von_Dir_Definierte_Ganzzahlvariable

// ... einen Wert eingibt, dann schreibst Du mit

cout << NFahrzeug[VDDG-1]->fahrzeugNummer << '\n';
cout << NFahrzeug[VDDG-1]->leistung << '\n';

// ... und so weiter genau die Eigenschaften auf das Standardausgabegerät
// (Bildschirm), die zu dem Fahrzeug gehören, das der Benutzer angegeben
// hat. < so jetzt bin ich gespannt ob jemandem eine kompaktere Erklärung
// mit STL - Quatsch einfällt >
// hoffe ich konnte Dir ein bisschen weiter helfen
    0
  • V
     

    Fahrzeug NFahrzeug = new Fahrzeug[3] (1,70,'c',50,'b');
//Find ich persönlich hübscher, da wir dann nur eine Konstruktor aufruf für 
//Nfahrzeug haben und es ist kürzer :)
//Und wie dir aufgefallen ist, sind ja nun alle Objekte gleich...

// und wenn schließlich der Benutzer mit ... 
int foo;
cin >> foo;
//Vielleicht noch falsche Eingaben etc abfangen .. 

// ... einen Wert eingibt, dann schreibst Du mit (wieso denn da #define?, so
//bekommt man aber keine Variablen ...)

cout << NFahrzeug[foo-1]->fahrzeugNummer << '\n';
cout << NFahrzeug[foo-1]->leistung << '\n';

// ... und so weiter genau die Eigenschaften auf das Standardausgabegerät
// (Bildschirm), die zu dem Fahrzeug gehören, das der Benutzer angegeben
// hat. < so jetzt bin ich gespannt ob jemandem eine kompaktere Erklärung
// mit STL - Quatsch einfällt > (man könnte vector verwenden :), hab ich jetz aber keine lust zu ...
// hoffe ich konnte Dir ein bisschen weiter helfen

//Hier dürfen wir
delete[] NFahrzeug;
//nicht vergessen =)
    0
  • ?

    [cpp]
    Fahrzeug NFahrzeug = new Fahrzeug[3] (1,70,'c',50,'b');
    //Find ich persönlich hübscher, da wir dann nur eine Konstruktor aufruf für
    //Nfahrzeug haben und es ist kürzer 🙂
    //Und wie dir aufgefallen ist, sind ja nun alle Objekte gleich...
    // new liefert einen Zeiger auf Fahrzeug, und Konstruktoren mit Parametern
    //zusammen mit dem new-Operator? Ob das gut geht?

    // und wenn schließlich der Benutzer mit ...
    int foo;
    cin >> foo;
    //Vielleicht noch falsche Eingaben etc abfangen ..
    //Da hast Du völlig recht

    // ... einen Wert eingibt, dann schreibst Du mit (wieso denn da #define?, so
    //bekommt man aber keine Variablen ...)
    //Wollte mir nur nicht die Finger wund schreiben bei den nächsten
    //Codezeilen, und setzte die Definition der Variablen voraus

    cout << NFahrzeug[foo-1]->fahrzeugNummer << '\n';
    cout << NFahrzeug[foo-1]->leistung << '\n';

    // ... und so weiter genau die Eigenschaften auf das Standardausgabegerät
    // (Bildschirm), die zu dem Fahrzeug gehören, das der Benutzer angegeben
    // hat. < so jetzt bin ich gespannt ob jemandem eine kompaktere Erklärung
    // mit STL - Quatsch einfällt > (man könnte vector verwenden :), hab ich jetz /// aber keine lust zu ...
    // In dem Beispiel wär <vector> außerdem wieder
    // einmal so ein Fall vom Typ 'mit Kanonen auf Mücken schießen'
    // hoffe ich konnte Dir ein bisschen weiter helfen

    //Hier dürfen wir
    delete[] NFahrzeug;
    //nicht vergessen 🙂
    //Oder das dem OS überlassen, wenn wir am Programmende angelangt sind, wie
    //in diesem Fall
    [/cpp]

    😉

    0
  • O

    Und das mit new[] und dem Konstruktoraufruf geht wirklich...? Wäre mir neu.

    std::vector<Fahrzeug> fahrzeuge(3, Fahrzeug(1,70,'c',50,'b'));

unsigned index;
std::cin >> index;
std::cout << fahrzeuge[index].foo() << endl;

    Geht allerdings nur, wenn Fahrzeug einen Kopierkonstruktor hat.

    0
Anmelden zum Antworten