Aufgabe :
Schreiben Sie anschließend ein C++ Programm, das folgende Aufgaben erledigt:
• Anlegen einer Variable des von Ihnen erstellten Struct-Datentyps (siehe oben).
• Einlesen der Elemente der Struct-Variable.
• Ausgabe der Elemente der Struct-Variable.
Hinweise:
• Verwenden Sie zum Einlesen der Daten über die Tastatur ’cin’
• Verwenden Sie zur Ausgabe der Daten ’cout’

Den Rest schaffst du ja sicher allein ...

#include <iostream>

int main()
{

}

Hallo Leute,
kann jemand mir bitte bei dieser Aufgabe helfen ? Danke im Voraus.
Struct-Datentyp ist für diese Dateien:
• KFZ-Modell
• Hersteller
• Baujahr
• Laufleistung
• Sitzanzahl

Du meinst Daten.

Ja, um natürlich eine Klasse zu definieren die diese Membervariablen hat, müssen wir erstmal ein Paar Dinge klären.

Welchen Typ hat jede Eigenschaft? Die Meisten sind einfache ganzzahlige Basisdatentypen, wie int . Aber auch bei den ganzzahligen Basisdatentypen muss man zwischen Größe (Wertebereich) und Vorzeichenbehaftung (kann der Wert negativ sein?) unterscheiden.

• KFZ-Modell/Hersteller: Hier bietet sich als einfachste Lösung entweder ein String oder eine Enumeration an. Eine Enumeration ist mehr oder weniger eben eine Aufzählung (engl. enumeration ), die mit dem Schlüsselwort enum eingeführt wird:

enum class Model
{
    eg74,
    dieser_eine_dessen_name_ich_immer_vergesse,
    // ... (weitere Modelle auflisten)
};

Strings kennst du bestimmt schon - dafür gibt es ja in der Standardbibliothek die Klasse std::string , die du dann einfach als Membervariable benutzen kannst.
Du kannst auch eine eigene Klasse für das Modell schreiben.

• Baujahr: Das wird ein einfaches unsigned . unsigned ist der bekannteste vorzeichenlose Basisdatentyp, der fast immer mindestens ganzzahlige Werte bis zu $2^{32}-1$ (ca. Vier Milliarden) stauen kann, was für viele Anwendungsfälle mehr als ausreichend ist. Eigentlich gibt es auch keinen direkten Grund, etwas kleineres zu nehmen, selbst wenn die Werte nicht besonders groß werden können.
• Laufleistung: Die einfachste Lösung wäre (wieder mit unsigned ) eine Jahreszahl festzulegen. Aber besser: Kilometerstand. Das ist gängiger. Und weniger Arbeit, da muss man sich nichts weiteres mehr überlegen.
• Sitzanzahl: Einfach: Das wird wieder ein unsigned .

Zugriff auf die Member? Hier einfach direkt ohne große Umschweife wie in C, weil es so einfach ist und du erstmal nur die Grundlagen willst.
Später kannst du Sachen kapseln, unveränderbar machen (Baujahr), dementsprechend Konstruktoren schreiben, die Stream-Operatoren überladen. Ach, so viel. :schnief:

Erster Code:

struct Car
{
    enum class Model
    {
        unknown,
        ak_47,
        flop
    } model;

    enum class Manufacturer
    {
        opel, // Auf opel greifst du von Außerhalb der Klasse so zu: Car::Manufacturer::opel
        iomega,
        sony
    } manufacturer;

    unsigned buildYear; // Baujahr
    unsigned mileage; // Laufleistung
    unsigned seatCount;
};

Aufgabe :
Schreiben Sie anschließend ein C++ Programm, das folgende Aufgaben erledigt:
• Anlegen einer Variable des von Ihnen erstellten Struct-Datentyps (siehe oben).
• Einlesen der Elemente der Struct-Variable.
• Ausgabe der Elemente der Struct-Variable.
Hinweise:
• Verwenden Sie zum Einlesen der Daten über die Tastatur ’cin’
• Verwenden Sie zur Ausgabe der Daten ’cout’

Das schaffste auch so.

Aber auch bei den ganzzahligen Basisdatentypen muss man zwischen Größe (Wertebereich) [...] unterscheiden.

Mach ich nie. Macht ihr das? Ich nehme immer int oder unsigned, außer ich brauche wirklich unbedingt etwas größeres.

Sone schrieb:

Aber auch bei den ganzzahligen Basisdatentypen muss man zwischen Größe (Wertebereich) [...] unterscheiden.

Mach ich nie. Macht ihr das? Ich nehme immer int oder unsigned, außer ich brauche wirklich unbedingt etwas größeres.

Ne, ich auch nicht. Nicht oft, jedenfalls, nur wo es Sinn macht. Siehe auch die Ergänzung bei unsigned .
Es gibt Fälle, wo man aber eben auch Werte > 2^32 speichern muss. Da muss man berücksichtigen, dass unsigned nicht unendlich große Werte speichern kann.

Jetzt aber nicht abschweifen.

Du kennst bestimmt die Shift-Operatoren >> und <<, die für die Stream-Klassen ostream und istream überladen wurden.

Um mit cin eine Variable einlesen zu können, nutzt du einfach folgenden Ausdruck:

unsigned i;
std::cin >> i; // Kennst du. Hoffentlich.

Um zu Prüfen, ob das Einlesen erfolgreich war, behandelst du std::cin einfach wie ein bool (so kannst du std::cin aber nicht immer behandeln):

if( std::cin >> i )
 // ... Einlesen erfolgreich, mit i arbeiten
else
   std::cerr << "Eingabe fehlgeschlagen!"; // cerr nutzt man zum Ausgeben von Fehlermeldungen.

Was vielleicht ein wenig zu fortgeschritten ist, allerdings die allgemeine Variante wäre, ist den Operator zum Extrahieren, >>, auch für istream und Car zu überladen. Das macht für dein Beispiel allerdings keinen Sinn, weil du sicher Abfragen in der Konsole schreiben willst:

Modell: ak_47
Hersteller: ...

Dafür musst du tatsächlich einfach ein Car-Objekt instantiieren und seine Membervariablen einlesen:

Car car;

std::cout << "Sitzanzahl: ";
std::cin >> car.seatCount;

// Bzw., wenn man noch eine Abfrage einbauen will:
if( !(std::cin >> car.seatCount) ) // Wenn das Einlesen fehlschlägt:
{
    std::cerr << "Falsche Eingabe!\n";
    return -1; // Wenn du in der main() bist. Dann würdest du hier einen Fehlerwert zurückgeben ([c]-1[/c] ist Konvention).
}

Und weil ich dich nicht mag, hau ich dir jetzt das vor die Nase.

Car car;
    if( (std::cout << "Sitzanzahl: ", std::cin >> car.seatCount)
     && (std::cout << "Kilometer: ", std::cin >> car.mileage)
     && (std::cout << "Baujahr: ", std::cin >> car.buildYear) )
        std::cout << "Fein!\n";
    else
    {
        std::cerr << "Versuch's noch mal!";
        return -1;
    }