Benutzer:Havaniceday/C++ Techniken

↑ C++

Hinweis: Du darfst diese Seite editieren!

Ja, wirklich. Es ist schön, wenn jemand vorbeikommt und Fehler oder Links korrigiert und diese Seite verbessert. Sollten deine Änderungen aber der innehabenden Person dieser Benutzerseite nicht gefallen, sei bitte nicht traurig oder verärgert, wenn sie rückgängig gemacht werden.
Wikipedia ist ein Wiki, sei mutig!

Ein-/Ausgabe überladen

Mit Hilfe des Rechtsshift- und Linksshift-Operators. Die Ein-/Ausgabe wird innerhalb der Operatorfunktion auf einfache, schon implementierte Ein-/Ausgaben heruntergebrochen.

struct Point {
    int x;
    int y;
};

std::ostream& operator<<( std::ostream& ostr, const Point& p)
{
    return ostr << '(' << p.x << ';' << p.y << ')';
}
std::istream& operator>>( std::istream& istr, Point& p )
{
    char dump;
    istr >> dump >> p.x >> dump >> p.y >> dump;
    return istr;
}

Bidirektionale Liste

Hier ist eine Beispielimplementation einer bidirektionalen Liste. Gut zu sehen ist auch, wie ein Iterator implementiert wird.

/* Example implementation of a bidirectional list, coded by JLBorges,
 * original post is at http://www.cplusplus.com/forum/beginner/246185/
 */

#include <iostream>
#include <initializer_list>
#include <string>

template <typename T>
class List
{
private:

    std::size_t sz = 0;
    
    struct Node { 
        T value;
        Node *prev;
        Node *next;
    };
    
    Node * first = nullptr;
    Node * last  = nullptr;
    
    class Iterator
    {
        private:
            Node * current;
            List & lst;
            Iterator( Node* n, List& l) : current(n), lst(l) {}
            friend List;
        
        public:
            T & operator* () { return current->value; }
            T* operator-> () { return &**this; }
            
            Iterator & operator++ () { current = current->next; return *this; }
            Iterator operator++(int) { const auto tmp = *this; ++*this; return tmp; }
            Iterator & operator-- () { current = (current? current->prev : lst.last); return *this; }
            Iterator operator--(int) { const auto tmp = *this; --*this; return tmp; }
            
            bool operator== ( const Iterator& that ) const { return current == that.current; }
            bool operator!= ( const Iterator& that ) const { return !(*this == that); }
    };

    public:    
        Iterator begin() { return {first, *this};  }
        Iterator end() { return {nullptr, *this};  }
    
        std::size_t size() const { return sz; }
        bool empty() const { return size() == 0; }
    
        void push_back( const T & v )
        {
            if( empty() ) first = last = new Node{ v, nullptr, nullptr };
            else { last->next = new Node{ v, last, nullptr }; last = last->next; }
            ++sz;
        }
        void pop_back()
        {
            if( size() == 1 ) { delete first; first = last = nullptr; }
            else { last = last->prev; delete last->next; last->next = nullptr; }
            --sz;
        }
        
        List() noexcept = default;
        List( std::initializer_list<T> ilist ) { for( const T& v : ilist ) push_back(v); }
        ~List() { while( !empty() ) pop_back(); }
};

int main()
{
    List<std::string> lst { "hello", "my", "little", "friend" };
    for( const auto& str : lst ) std::cout << str << '\n';
}

†