C++-Programmierung/ Eine Matrix-Bibliothek – mitrax/ Ein- und Ausgabe

Aus Wikibooks
Zur Navigation springen Zur Suche springen


Wir werden uns in diesem Kapitel mit der Ein- und Ausgabe von Matrizen und deren Proxyklassen beschäftigen. Die Ein-/Ausgabe soll dabei in einem Klartextformat erfolgen. Die Boost-Bibliothek uBLAS repräsentiert Strukturen aus der linearen Algebra, darunter auch Matrizen. Wir werden uns an deren Ein-/Ausgabeformat orientieren, so dass ein Austausch mit Programmen, die diese Bibliothek nutzen, problemlos möglich ist. Als Vorbedingung sei noch angemerkt, dass das Ein- und das Ausgabeformat für einen Datentyp prinzipiell identisch oder zumindest kompatibel sein sollte. Auf diese Weise können Daten ausgegeben und später wieder eingelesen werden, ohne Sie manipulieren zu müssen.

Das Matrizenformat[Bearbeiten]

Jede Matrix in Textform beginnt mit einer öffnenden eckigen Klammer ([). Dann folgt die Anzahl der Zeilen als vorzeichenlose Ganzzahl. Anschließend muss ein Komma folgende (,). Danach die Anzahl der Spalten als vorzeichenlose Ganzzahl. Gefolgt von einer schließenden eckigen Klammer (]). Diesen Teil bezeichnen wir als Header, da er die Dimension der Matrix enthält.

Auf den Header folgt der Körper der Matrix. Er besteht aus einer beliebigen Anzahl gleichgroßer Zeilen, wobei gleichgroß sich auf die Anzahl der enthaltenen Elemente bezieht. Die Zeilen werden komplett in runde Klammern eingefasst und sind durch Kommata separiert. Jede Zeile ist wiederum in runde Klammern eingefasst und die Elemente sind wiederum durch Kommata separiert. Das Format der Elemente hängt vom jeweiligen Datentyp der Matrixelemente ab und kann daher nicht allgemein beschrieben werden. Die genannten Zeichen und die Elemente, sowie die vorzeichenlosen Ganzzahlen, werden als Token bezeichnet. Alle Token des Formats können durch eine beliebige Anzahl von Whitespaces getrennt sein.

Im Folgenden sehen Sie Beispiele für eine, aus ganzzahligen Werten bestehende, Matrix, sowie eine für eine Matrix, die Elemente von Typ std::complex< int > enthält. Die beiden Matrizen werden jeweils in einer kompakten und einer übersichtlichen Schreibweise dargestellt. Beide Schreibweisen entsprechen dem vorgegeben Format.

// Matrix aus Ganzzahlen
[3,3]((2,4,6),(8,10,12),(14,16,18))

[3,3](
(         2,         4,         6),
(         8,        10,        12),
(        14,        16,        18)
)

// Matrix aus komplexen Werten
[3,3](((3,0),(6,9),(9,36)),((12,81),(15,144),(18,225)),((21,324),(24,441),(27,576)))

[3,3](
(     (3,0),     (6,9),    (9,36)),
(   (12,81),  (15,144),  (18,225)),
(  (21,324),  (24,441),  (27,576))
)

Beide Varianten sollen durch mit dem Eingabeoperator funktionieren und der Ausgabeoperator soll, abhängig von zwei gesetzten Ausgabemanipulatoren, in der Lage sein, beide Ausgaben zu produzieren. Die Erste eignet sich gut für einen Austausch zwischen verschiedenen Programmen oder zur Speicherung für die spätere Verwendung. Die zweite Ausgabevariante ist gut für eine Betrachtung durch einen Menschen geeignet und lässt sich praktischerweise auch hervorragend in eine Tabellenkalkulation übertragen.

Ausgabemanipulatoren[Bearbeiten]

Ehe wir uns der Ausgabe selbst widmen, werden wir uns noch der Möglichkeit zu Manipulation derselben zuwenden. Diese stehen in der Datei iomanip.hpp. Es wurde ja bereits gesagt, dass wir zwei Ausgabemanipulatoren für unsere Matrix schreiben wollen. Der Erste bestimmt die Mindestbreite, die ein Matrixelement belegen soll. Auf diese Weise kommt oben die gleichmäßige Spaltenbreite zu Stande. Der zweite Manipulator soll einen mehrzeiligen Ausgabemodus aktivieren bzw. deaktivieren, so dass, falls gewünscht, jede Matrixzeile auch in der Ausgabe auf einer eigenen Zeile steht.

Für beide Manipulatoren, müssen wir Informationen in dem Ausgabestream speichern, auf dem wir unsere Matrix ausgeben wollen. Die C++-Standardbibliothek bietet zu diesem Zweck in der Klasse std::ios_base eine statische Methode xalloc() an. Diese gibt uns einen eindeutigen Index zurück, der auf ein long verweist, in dem wir Daten für unsere Zwecke unterbringen können. Der Ausgabestream selbst, erlaubt uns mittels der Methode iword() auf diesen long zuzugreifen. Die Methode bekommt den eindeutigen Index als Parameter und gibt eine Referenz auf den long zurück.

Nehmen wir uns zunächst den Manipulator für die Elementmindestbreite von. Um den Zugriff auf unsere Speicherposition einfach zu gestalten, verpacken wir die eben genannten Methoden in einer Funktion, die uns eine Referenz auf den long zurückgibt. Wir platzieren diese Funktion im Namensraum detail und nennen sie element_width_flag(). Die Funktion enthält eine statische konstante Variable für den eindeutigen Index. Diese wird beim ersten Aufruf der Methode mit einem gültigen Index initialisiert. Außerhalb der Methode kann somit kein direkter Zugriff auf die Speicherposition erfolgen, da diese nicht bekannt ist. Innerhalb der Funktion müssen wir nun nur noch die Methode iword() unseren Ausgabestream mit dem eindeutigen Index aufrufen und schon können wir die gewünschte Referenz zurückliefern.

Nuvola-inspired-terminal.svg
1 long& element_width_flag(std::ios_base& s){
2     static int const unique_index = std::ios_base::xalloc();
3     return s.iword(unique_index);
4 }

Als nächstes legen wir eine Funktion zum Lesen und eine zum Schreiben auf die entsprechende Speicherstelle eines Streams an. Diese beiden Methoden können vom Nutzer verwendet werden und stehen daher im direkt Namensraum mitrax.

Nuvola-inspired-terminal.svg
1 long get_element_width_flag(std::ios_base& s){
2 	return detail::element_width_flag(s);
3 }
4 
5 void set_element_width_flag(std::ios_base& s, long n){
6 	detail::element_width_flag(s) = n;
7 }

Das würde genügen, um eine entsprechende Ausgabe realisieren zu können, jedoch wollen wir den Wert gern direkt als Manipulator auf den Ausgabestream schieben können. So wie es etwa bei std::setw() der Fall ist. Wir müssen daher eine Helferklasse schreiben, die ein Objekt erzeugt, welches dann als Parameter an einen Ausgabeoperator übergeben werden kann. Dieser wird schließlich die Set-Funktion aufrufen. Der Ausgabeoperator muss dabei als Template realisiert sein, um alle Arten von Streams zu unterstützen. Das ganze Konstrukt sieht daher so aus:

Nuvola-inspired-terminal.svg
 1 class set_element_width{
 2 public:
 3     set_element_width(long width):width_(width){}
 4 
 5 private:
 6     long const width_;
 7 
 8     template < class charT, class traits >
 9     friend std::basic_ostream< charT, traits >& operator<<(
10         std::basic_ostream< charT, traits >& os, set_element_width const& f
11     ){
12         set_element_width_flag(os, f.width_);
13         return os;
14     }
15 };

Die Definition des befreundeten Funktionstemplates innerhalb der Klasse ist reine Bequemlichkeit. Insbesondere spielt es keine Rolle, dass die Funktion im private-Bereich definiert ist. Die Einrückung wurde hier lediglich vorgenommen, um Verwirrung zu vermeiden. Es sein außerdem noch einmal daran erinnert, dass bei der Definition einer Funktion innerhalb einer Klassendefinition, die Funktion implizit inline ist, daher müssen wir dies hier nicht nochmal explizit angeben. Oft wird vergessen, dass diese Regel auch auf Nicht-Member wie friend und static-Funktionen zutrifft.

Die Definition des anderen Manipulators ist weitgehend analog. Da wir hier lediglich ein Bit Information benötigen, werden wir es so einrichten, dass später eventuelle weitere Flags dieser Art, an der eindeutigen Speicherstelle abgelegt werden können. Wir Verwenden eine Enumeration um die Bitposition innerhalb der Speicherstelle festzuhalten. Auch diese Information geht den Benutzer nichts an, daher steht auch die Enumeration im Namensraum detail. Das Ganze sieht wie Folgt aus:

Nuvola-inspired-terminal.svg
 1 namespace detail{
 2     struct format_flags{
 3         static long const multi_line = 0x01;
 4     };
 5 
 6     long& format_flags_flag(std::ios_base& s){
 7         static int const unique_index = std::ios_base::xalloc();
 8         return s.iword(unique_index);
 9     }
10 }
11 
12 bool get_multi_line_flag(std::ios_base& s){
13     return detail::format_flags_flag(s) & detail::format_flags::multi_line;
14 }
15 
16 void set_multi_line_flag(std::ios_base& s, bool f){
17     if(f){
18         detail::format_flags_flag(s)

Da wir diesmal nur zwei mögliche Zustände haben, wäre es angenehm, wenn wir nicht jedes mal ein Objekt erzeugen müssten, wenn wir den Ausgabemodus ändern wollen. Daher stellen wir die zwei möglichen Instantiierungen der Klasse als Variablen bereit. Diese lassen sich dann Verwenden wie std::endl.

Nuvola-inspired-terminal.svg
1 set_multi_line multi_line  = true;
2 set_multi_line single_line = false;

Um eine der formatierten Ausgaben von oben, aus einer Matrix m auf dem Ausgabestream std::cout zu erzeugen, können wir folgendes schreiben, sobald wir die Ausgabe selbst realisiert haben.

Nuvola-inspired-terminal.svg
1 std::cout << mitrax::multi_line << mitrax::set_element_width(10) << m << std::endl;

Der restliche Text des Kapitels bezieht sich auf Inhalte der Datei io.hpp.

Ausgabe von Matrizen[Bearbeiten]

Wir werden die Ausgabe zunächst auf einem Puffer realisieren und diesen zum Schluss, auf dem eigentlichen Stream ausgeben. Das macht die Ausgabe gelegentlich etwas effizienter und falls irgendwo eine Ausnahme geworfen wird, vermeiden wir, dass nur ein Teil der Matrix ausgegeben wird. Das eine Ausnahme geworfen wird, kann beispielsweise im Ausgabeoperator eines Elements passieren, über diesen wissen wir ja nichts. Wenn wir einen Puffer verwenden, wird unsere Matrix entweder vollständig oder gar nicht ausgegeben.

Als Puffer verwenden wir einen passenden Stringstream. Dieser muss vom eigentlichen Ausgabestream die aktuellen Flags, die Lokalisierungseinstellungen und die Gleitkommagenauigkeit übernehmen. Außerdem müssen wir uns natürlich unsere Manipulatoren aus dem Originalstream extrahieren. Diese speichern wir allerdings gleich in zwei Variablen, da wir diese Informationen ja direkt verwenden wollen. Bei der Ausgabe werden die Matrixelemente alle einmal durchlaufen, daher können wir einen Matrixiterator verwenden. Auf diese Weise müssen wir nicht jedes mal aufwendig die aktuelle Position innerhalb der Matrix berechnen. Die Ausgabe erfolgt ja genau in der Reihenfolge, in der der Iterator durch die Matrix läuft. Um die Übersicht ein wenig zu steigern, werden wir außerdem vorweg die Anzahl der Zeilen und Spalten in zwei Konstanten speichern.

Da der Zugriff auf die Typen innerhalb der Matrix relativ kompliziert aussieht, werden wir die benötigten Typen per typedef zur Verfügung stellen. Auch das sollte einer besseren Übersicht zuträglich sein. Als Erstes geben wir den Header der Matrix aus und anschließend, unter Berücksichtigung der beiden Manipulatoren, den Körper der Matrix. Zum Schluss müssen wir nur noch unseren Puffer auf dem eigentlichen Ausgabestream ausgeben und natürlich wie üblich diesen wieder als Referenz zurückgeben, damit weitere Ausgaben verkettet werden können.

Nuvola-inspired-terminal.svg
 1 template < class charT, class traits, typename T, typename Container >
 2 inline std::basic_ostream< charT, traits >&
 3 operator<<(std::basic_ostream< charT, traits >& os, matrix< T, Container > const& m){
 4     typedef typename matrix< T, Container >::size_type      size_type;
 5     typedef typename matrix< T, Container >::const_iterator const_iterator;
 6 
 7     // Ausgabe erfolgt zunächst auf Puffer
 8     std::basic_ostringstream< charT, traits, std::allocator< charT > > tos;
 9     tos.flags(os.flags());
10     tos.imbue(os.getloc());
11     tos.precision(os.precision());
12 
13     // Manipulatoren
14     long const output_width = get_element_width_flag(os);
15     bool const multi_line = get_multi_line_flag(os);
16     // Schneller Zugriff
17     size_type const rows    = m.rows();
18     size_type const columns = m.columns();
19     // Elementweise durchgehen mittels Iterator
20     const_iterator iter = m.begin();
21 
22     // Ausgabe Header
23     tos << '[' << rows << ',' << columns << "](";
24     if(multi_line) tos << '\n';
25     // Ausgabe erste Zeile
26     if(rows){
27         tos << '(';
28         // Ausgabe erstes Element
29         if(columns){
30             tos << std::setw(output_width) << *iter++;
31         }
32         // Ausgabe restliche Element
33         for(typename matrix< T, Container >::size_type j = 1; j < columns; ++j){
34             tos << ',' << std::setw(output_width) << *iter++;
35         }
36         tos << ')';
37     }
38     // Ausgabe restliche Zeilen
39     for(typename matrix< T, Container >::size_type i = 1; i < rows; ++i){
40         tos << ',';
41         if(multi_line) tos << '\n';
42         tos << '(';
43         // Ausgabe erstes Element
44         if(columns){
45             tos << std::setw(output_width) << *iter++;
46         }
47         // Ausgabe restliche Element
48         for(typename matrix< T, Container >::size_type j = 1; j < columns; ++j){
49             tos << ',' << std::setw(output_width) << *iter++;
50         }
51     tos << ')';
52     }
53     if(multi_line) tos << '\n';
54     tos << ')';
55 
56     // Ausgabe auf Stream und Streamrückgabe
57     return os << tos.str().c_str();
58 }

Über den Datentyp der Zeichen müssen Sie sich übrigens keine Gedanken machen, diese werden bei der Ausgabe implizit in den richtigen Datentyp konvertiert.

Eingabe von Matrizen[Bearbeiten]

Die Eingabe von Matrizen verlangt des Öfteren, dass als nächstes ein bestimmtes Zeichen folgen muss. Diese Prüfung können wir in eine Hilfsfunktion auslagern, welche natürlich wieder im Namensraum detail unterzubringen ist. Wir werden Sie innerhalb des Eingabeoperators mittels using-Deklaration verfügbar machen. Die Funktion bekommt den Eingabestream und das erwartete Zeichen als Parameter. Wenn der Stream nicht in Ordnung ist, gibt die Funktion sofort false zurück. Andernfalls wir ein Zeichen eingelesen und, sofern die Eingabe geklappt hat, überprüft ob dieses das erwartete Zeichen ist. Ist dies der Fall, wird true zurückgegeben. Andernfalls wird das Zeichen in den Stream zurückgeschriebenen und das fail-Bit gesetzt. Die Funktion gibt dann false zurück.

Nuvola-inspired-terminal.svg
1 template < class charT, class traits >
2 inline bool input_equal(std::basic_istream< charT, traits >& is, charT const& should_be){
3     if(!is) return false;
4     charT in;
5     if(is >> in && in == should_be) return true;
6     is.putback(in);
7     is.setstate(std::ios_base::failbit);
8     return false;
9 }

Die Eingabefunktion selbst wird dadurch einigermaßen Überschaubar. Wir nutzen zunächst wieder typedef um die benötigten Typen abzukürzen und legen uns zwei Variablen für die Anzahl der Zeilen und Spalten an. Die Dimension der einzugebenden Matrix ist unabhängig von der vorherigen Dimension des Matrixobjekts. In einer Kette von Eingaben, innerhalb einer if-Bedingung, lesen wir nun den Header ein. Schlägt eine der Operationen fehl, ist die Bedienung erfüllt und der Stream wird zurückgegeben. Das fail-Bit ist bei der fehlgeschlagenen Eingabe an dieser Stelle bereits gesetzt wurden, daher müssen wir dies nicht mehr tun.

Wenn die Headereingabe geklappt hat, dann müssen als nächstes die Elemente eingelesen werden. Auch hier kann es wieder passieren, dass irgendwo eine Ausnahme geworfen wird oder die Eingabe schlicht ein fehlerhaftes Format besitzt und die Eingabe deshalb abgebrochen wird. In jedem Fall sollten wir sichergehen, dass wir alle Elemente korrekt einlesen konnten, bevor wir das matrix-Objekt tatsächlich verändern. Wir werden die Werte daher zunächst in einen Container einlesen. Auch hier können wir wieder einen Iterator verwenden und uns darauf verlassen, dass dieser immer auf das richtige Element zeigt. Wenn die Eingabe erfolgreich war, reinitiallisieren wir unser matrix-Objekt mit der neuen Dimension und den neuen Daten. Dabei werden einfach die Container getauscht, so dass wir hier höchstwahrscheinlich keine aufwendige Kopie aller Elemente durchführen müssen. Das späte setzen der Daten ist somit nahezu kostenlos. Zum Schuss müssen wir natürlich auch wieder den Eingabestream zurückgeben.

Nuvola-inspired-terminal.svg
 1 template < class charT, class traits, typename T, typename Container >
 2 inline std::basic_istream< charT, traits >&
 3 operator>>(std::basic_istream< charT, traits >& is, matrix< T, Container >& m){
 4     using detail::input_equal;
 5 
 6     typedef typename matrix< T, Container >::size_type      size_type;
 7     typedef typename matrix< T, Container >::const_iterator const_iterator;
 8     typedef std::vector< T >                                container_type;
 9 
10     // Neue Dimension der Matrix
11     size_type rows;
12     size_type columns;
13 
14     // Header einlesen
15     if(
16         !input_equal(is, charT('[')) ||
17         !(is >> rows)                ||
18         !input_equal(is, charT(',')) ||
19         !(is >> columns)             ||
20         !input_equal(is, charT(']')) ||
21         !input_equal(is, charT('('))
22     ) return is;
23 
24     // Daten erst komplett Einlesen und dann gegen Originale tauschen
25     container_type elements(rows * columns);
26     typename container_type::iterator tmp_iter = elements.begin();
27     // Lese n-1 Zeilen
28     for(size_type i = size_type(); i < rows-1; ++i){
29         if(
30             !input_equal(is, charT('('))
31         ) return is;
32         // Lese n-1 Spalten
33         for(size_type j = size_type(); j < columns-1; ++j){
34             if(is >> *tmp_iter++ && input_equal(is, charT(','))) continue;
35             return is;
36         }
37         if( // Lese n-te Spalten
38             !(is >> *tmp_iter++)         ||
39             !input_equal(is, charT(')')) ||
40             !input_equal(is, charT(','))
41         ) return is;
42     }
43     // Lese n-te Zeilen
44     if(
45         !input_equal(is, charT('('))
46     ) return is;
47     // Lese n-1 Spalten
48     for(size_type j = size_type(); j < columns-1; ++j){
49         if(is >> *tmp_iter++ && input_equal(is, charT(','))) continue;
50         return is;
51     }
52     if( // Lese n-te Spalten
53         !(is >> *tmp_iter++)         ||
54         !input_equal(is, charT(')')) ||
55         !input_equal(is, charT(')'))
56     ) return is;
57 
58     // Eingelesene Werte gegen Matrixwerte tauschen
59     m.reinit(rows, columns, elements);
60 
61     return is;
62 }

Beachten Sie, dass Sie sich bei der Eingabe sehr wohl Gedanken über den Datentyp der Literale machen müssen. Da wir keine brauchbare Möglichkeit haben, für unterschiedliche Datentypen auch unterschiedliche Literale zu verwenden, greifen wir auf eine Typumwandlung zurück. Diese realisieren wir mittels temporärer Objekterzeugung. Speziell für nicht eingebaute Datentypen ist dies die richtige Aussage und nebenbei sind diese auch der Grund, warum es nach dem aktuellen C++-Standard unmöglich wäre, unterschiedliche Literale zu nutzen. Benutzerdefinierte Literale werden erst mit dem kommenden C++-Standard eingeführt und derzeit gibt es keinen Compiler, der dies bereits beherrscht.

Sie haben nun die Möglichkeit Matrizen formatiert auszugeben und Sie später wieder einzulesen. Wenn Sie möchten können Sie ja mal das oben gezeigt Beispiel, für eine Ausgabe mit aktiven Manipulatoren, ausprobieren. Das sollte jetzt funktionieren.

Proxys ausgeben[Bearbeiten]

Das Ein-/Ausgabeformat für die Proxyklassen entspricht dem uBLAS-Format für Vektoren. In eckigen Klammern wird die Anzahl der Elemente angegeben und anschließen in runden Klammern eingeschlossen und durch Kommata separiert, die Elemente. Auch hier können zwischen den Token natürlich wieder beliebig viele Whitespaces stehen. Es lässt sich also nicht mehr erkennen, ob es sich um einen Zeilen- oder einen Spaltenproxy gehandelt hat. Wir können die beiden Ausgaben also in einem gemeinsamen Funktionstemplate realisieren.

Leider müssen wir für jede unserer vier Proxyklassen eine eigene Definition für den Ausgabeoperator angeben, da ja für Funktionstemplates nicht auf eventuell mögliche implizite Typumwandlungen geprüft wird. Wir müssen daher für die Proxys für nicht-konstante Matrizen selbst eine Definition schreiben, welche die Typumwandlung durchführt und dann die entsprechende Version mit Proxys für konstante Matrizen aufruft. Diese werden wiederum eine Funktionsinstanz des Funktionstemplats aufrufen, dass die Ausgabe richtungsunabhängig realisiert. Diese Template steht natürlich im Namensraum detail.

Das Funktionstemplate bekommt einen Iterator auf den Anfang der Zeile bzw. Spalte und natürlich deren Länge. Dies sind entsprechend auch die zusätzlichen Templateparameter. Die Ausgabe erfolgt zunächst wieder auf einen Puffer. Wir beachten die Ausgabemanipulatoren für minimal Elementbreite und den Mehrzeilenmodus. Ist letzter aktiv, geben wir den Header und den Körper jeweils in einer eigenen Zeile aus. Das ganze sieht folgendermaßen aus.

Nuvola-inspired-terminal.svg
 1 namespace detail{
 2     template < class charT, class traits, typename Iterator, typename Size >
 3     inline std::basic_ostream< charT, traits >&
 4     proxy_output(std::basic_ostream< charT, traits >& os, Iterator iter, Size const& size){
 5         // Ausgabe erfolgt zunächst auf Puffer
 6         std::basic_ostringstream< charT, traits, std::allocator< charT > > tos;
 7         tos.flags(os.flags());
 8         tos.imbue(os.getloc());
 9         tos.precision(os.precision());
10 
11         // Manipulatoren
12         long const output_width = get_element_width_flag(os);
13         bool const multi_line = get_multi_line_flag(os);
14 
15         // Ausgabe Header
16         tos << '[' << size << ']';
17         if(multi_line) tos << '\n';
18 
19         // Ausgabe der Zeile / Spalte
20         tos << '(';
21         if(size){
22             tos << std::setw(output_width) << *iter;
23             ++iter;
24         }
25         for(Size i = Size()+1; i < size; ++i){
26             tos << ',' << std::setw(output_width) << *iter;
27             ++iter;
28         }
29         tos << ')';
30 
31         // Ausgabe auf Stream und Streamrückgabe
32         return os << tos.str().c_str();
33     }
34 }
35 
36 template < class charT, class traits, typename Matrix >
37 inline std::basic_ostream< charT, traits >&
38 operator<<(std::basic_ostream< charT, traits >& os, row_const_proxy< Matrix > const& proxy){
39     return detail::proxy_output(os, proxy.cbegin(), proxy.columns());
40 }
41 
42 template < class charT, class traits, typename Matrix >
43 inline std::basic_ostream< charT, traits >&
44 operator<<(std::basic_ostream< charT, traits >& os, column_const_proxy< Matrix > const& proxy){
45     return detail::proxy_output(os, proxy.cbegin(), proxy.rows());
46 }
47 
48 template < class charT, class traits, typename Matrix >
49 inline std::basic_ostream< charT, traits >&
50 operator<<(std::basic_ostream< charT, traits >& os, row_proxy< Matrix > const& proxy){
51     return os << row_const_proxy< Matrix >(proxy);
52 }
53 
54 template < class charT, class traits, typename Matrix >
55 inline std::basic_ostream< charT, traits >&
56 operator<<(std::basic_ostream< charT, traits >& os, column_proxy< Matrix > const& proxy){
57     return os << column_const_proxy< Matrix >(proxy);
58 }

Die Ausgabe bietet keine großen Überraschungen. Im wesentlichen kombinieren wir ein paar der Techniken, die wir zuvor kennengelernt haben. Neues kommt an dieser Stelle nicht hinzu.

Proxys einlesen[Bearbeiten]

Beim Einlesen einer Zeile oder Spalte müssen wir beachten, dass wir die Länge nicht ändern können. Der eingegebene Vektor muss längenmäßig zu dem Proxy passen, in den eingelesen werden soll. Ist dies nicht gegeben werden wir die Eingabe abbrechen und das fail-Bit für den Stream setzen. Der Vergleich zwischen einer einzugebenden und einer vorgegeben Zahl, erinnert an das Einlesen erwarteter Zeichen und in der Tat, werden wir auch diesmal eine Helferfunktion gleichen Namens verwenden. Es ist zwar die einzige Stelle, an der innerhalb unserer Ein-/Ausgabefunktionen etwas anderes als ein Zeichen mit einem bestimmten Wert erwartet wird, aber es erhöht dennoch die Lesbarkeit des Quellcodes, eine Funktion mit verständlichem Namen für diese Aktion zu verwenden.

Wir lesen unser Elemente wieder zuerst vollständig in ein temporäres Feld. Diesmal verwenden wir dafür einfach einen std::vector. Da die Elemente am Ende ohnehin zugewiesen werden müssen, würde sich kein Vorteil daraus ergeben den container_type von matrix zu verwenden und gleichzeitig könnten wir eventuelle Nachteile nicht Abschätzen. Ansonsten gibt es auch hier keine großen Überraschungen. Die beiden Operatorüberladungen rufen wieder eine richtungsunabhängig geschrieben Funktionsinstanz eines Funktionstemplats aus detail aus und den Quellcode kennen Sie vom Prinzip her inzwischen auch schon.

Nuvola-inspired-terminal.svg
 1 namespace detail{
 2     template < class charT, class traits, class ShouldBe >
 3     inline bool input_equal(std::basic_istream< charT, traits >& is, ShouldBe const& should_be){
 4         ShouldBe in;
 5         if(is >> in && in == should_be) return true;
 6         is.setstate(std::ios_base::failbit);
 7         return false;
 8     }
 9 
10     template < class charT, class traits, typename Iterator, typename Size >
11     inline std::basic_istream< charT, traits >&
12     proxy_input(std::basic_istream< charT, traits >& is, Iterator iter, Size const& size){
13         typedef std::vector< typename Iterator::value_type > container_type;
14 
15         // Header einlesen und Länge prüfen
16         if(
17             !input_equal(is, charT('[')) ||
18             !input_equal(is, size)       ||
19             !input_equal(is, charT(']')) ||
20             !input_equal(is, charT('('))
21         ) return is;
22 
23         // Werte zunächst komplett in temporären Container einlesen
24         container_type elements(size);
25         typename container_type::iterator tmp_iter = elements.begin();
26         for(Size i = Size(); i < size-1; ++i){
27             if(is >> *tmp_iter++ && input_equal(is, charT(','))) continue;
28             return is;
29         }
30         if(
31             !(is >> *tmp_iter++) ||
32             !input_equal(is, charT(')'))
33         ) return is;
34 
35         // Eingelesene Werte übertragen
36         tmp_iter = elements.begin();
37         for(Size i = Size(); i < size; ++i){
38             *iter = *tmp_iter;
39             ++tmp_iter;
40             ++iter;
41         }
42 
43         return is;
44     }
45 }
46 
47 template < class charT, class traits, typename Matrix >
48 inline std::basic_istream< charT, traits >&
49 operator>>(std::basic_istream< charT, traits >& is, row_proxy< Matrix > proxy){
50     return detail::proxy_input(is, proxy.begin(), proxy.columns());
51 }
52 
53 template < class charT, class traits, typename Matrix >
54 inline std::basic_istream< charT, traits >&
55 operator>>(std::basic_istream< charT, traits >& is, column_proxy< Matrix > proxy){
56     return detail::proxy_input(is, proxy.begin(), proxy.rows());
57 }

Somit verfügen Sie nun über ein komplettes Ein-/Ausgabeinterface und können auch endlich etras von Ihren Matrizen und Proxyklassen sehen. Als nächstes werden wir ein recht seperates Thema, die Ausnahmebahandlung besprechen und anschließend führen wie einige grundlegende Rechenoperationen auf unseren Matrizen ein. Sie sollten danach in der Lage sein, mitrax selbst um beliebige Operationen zu erweitern.