Zu den Aufzeichnungen der tutorials.de-Live-Workshops
ERLEDIGT
NEIN
ANTWORTEN
3
ZUGRIFFE
959
EMPFEHLEN
  • An Twitter übertragen
  • An Facebook übertragen
AUF DIESES THEMA
ANTWORTEN
  1. #1
    Avatar von Jennesta
    Jennesta Jennesta ist offline Mitglied Gold
    Registriert seit
    Sep 2007
    Ort
    Aachen
    Beiträge
    199
    Hey Leute,
    ich soll mithilfe von Klassen einen Taschenrechner programmieren. In dem Teil, wo einige Dinge dazu erklärt sind gibt es folgende Beispielfunktion, die ich nicht ganz verstehe. Die Teile die mir komisch vorkommen habe ich markiert, ich hoffe mir kann einer den Sinn und die Funktion erklären.

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    class Employee
    {
        virtual [COLOR="Red"]ostream&[/COLOR] print([COLOR="Red"]std:ostream&[/COLOR] stream) const
        {
            stream << firstname << " " 
                   << familyname << " has hired on "
                   << hiringDate;
            return stream;
        }
    };

    Gruß Jennesta
     

  2. #2
    Cromon Cromon ist offline Mitglied Brillant
    Registriert seit
    Apr 2008
    Beiträge
    819
    Hallo Jennesta!

    std::ostream ist ein wesentlicher Teil der I/O-Abteilung der STL. Ostream steht hier für outputstream, was soviel wie Ausgabestrom bedeutet. Unter einem Ausgabestrom kann man natürlich ganz viel verstehen. Daher ist es nicht erstaunlich, dass viele andere Klassen davon erben und auch viele STL-Objekte von diesem Typ sind.

    So ist zum Beispiel cout auch ein ostream. Und zwar handelt es sich dabei um den Ausgabestrom, der in die Konsole geleitet wird.

    Ein anderer Ausgabestrom wäre zum Beispiel eine geöffnet Datei mit Schreibberechtigung.

    Hier mal zwei Beispiele dazu:
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    
    #include <iostream>
    #include <fstream>
     
    class Employee
    {
        std::string firstname, lastname;
    public:
        Employee(std::string finame, std::string laname) : firstname(finame), lastname(laname)
        {
        }
        virtual std::ostream& print(std::ostream& stream) const
        {
            stream << "Hello, I am " << firstname.c_str() << " " 
                   << lastname.c_str() << "!\n";
            return stream;
        }
     
    };
     
    int main()
    {
        Employee emp("Peter", "Mueller");
        emp.print(std::cout);
        std::ofstream ostr("Employees.txt", std::ios::app);
        emp.print(ostr);
    }

    Zuerst wird in der Konsole "Hello, I am Peter Mueller!" dargestellt, anschliessend wird die Datei Employees.txt gesucht oder erstellt und in die Datei wird "Hello, I am Peter Mueller" geschrieben.

    Wir sehen also, dass wir dank des Aufbaus der STL wirklich sehr vielseitige Klassen und Funktionen erstellen können (gerade auch in Verbindung mit überladenen Operatoren).

    Gruss
    Cromon
     

  3. #3
    Avatar von Jennesta
    Jennesta Jennesta ist offline Mitglied Gold
    Registriert seit
    Sep 2007
    Ort
    Aachen
    Beiträge
    199
    ok, das es etwas mit der ausgabe zu tun hat, habe ich mir schon fast gedacht, jedoch ist mir diese schreibweise, vorallem mit dem Bereichsoperator :: habe ich noch kaum erfahrungen gemacht.

    Schreibe ich also nicht cout in die print-Funktion, um die Funktion noch für andere Ausgabemedien bereitzuhalten?
    Weil für meine Zwecke würde das bisher vollkommen reichen und und mir die Arbeit mit den Klassen sehr vereinfachen, weil ich mich hier komplett neu einarbeiten muss.
     

  4. #4
    Avatar von devDevil
    devDevil devDevil ist offline Mitglied Platin
    Registriert seit
    Jun 2005
    Beiträge
    662
    Hmm nur wäre es eigtl. sinnvoller folgendes zu machen: operator<< überladen!
    Code cpp:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    
    #include <iostream>
    #include <fstream>
    #include <string>
     
    class Employee
    {
        std::string m_firstname;
        std::string m_lastname;
     
    public:
        Employee(std::string const& firstname, std::string const& lastname) // initialisisrungsliste kommt damit klar wenn lokale und membervariablen bezeichner identisch sind! u. const ref. bitte ...
            : m_firstname(firstname), m_lastname(lastname)
        {}
     
        friend std::ostream& operator<<(std::ostream& out, Employee const& rhs)
        { return rhs.print(out); } 
        
    protected:
        virtual std::ostream& print(std::ostream& out) const
        {    return out << m_lastname << ", " << m_firstname; } 
    };
     
    int main()
    {
        Employee emp("Peter", "Mueller");
        std::cout << emp << std::endl; // hier gehört das newline-zeichen hin ...
     
        std::ofstream file_stream("Employees.txt", std::ios_base::app);
        file_stream << emp << std::endl;
    }
    Geändert von devDevil (17.05.09 um 12:58 Uhr)
     

Ähnliche Themen

  1. ActionScript erklären
    Von chuvak im Forum Flash Plattform
    Antworten: 0
    Letzter Beitrag: 18.05.08, 16:53
  2. Schwierig zu erklären...
    Von PillePalle89 im Forum HTML & XHTML
    Antworten: 2
    Letzter Beitrag: 03.11.07, 18:11
  3. Properties in Klassen mit geerbten abstrakten Klassen
    Von Razorhawk im Forum .NET Café
    Antworten: 4
    Letzter Beitrag: 11.07.07, 14:35
  4. Antworten: 2
    Letzter Beitrag: 05.07.06, 14:55
  5. Schwierig zu erklären
    Von KangarOO im Forum Javascript & Ajax
    Antworten: 2
    Letzter Beitrag: 09.02.04, 07:32