zpr c++ quick reference

Ta strona jest tylko do odczytu. Możesz wyświetlić źródła tej strony ale nie możesz ich zmienić.
====== Biblioteka Boost Format ======
Biblioteka Boost Format dostarcza klasę do formatowania argumentów zgodnie z dostarczonym łańcuchem formatującym. Podstawowe różnice w stosunku do funkcji printf, to m.in.:
  * deterministyczne zachowanie, nawet w przypadku podania błędnych argumentów (generuje wyjątek lub ignoruje błąd, w zależności od ustawień).
  * naturalne wsparcie typów zdefiniowanych przez użytkownika.
  * podawanie argumentów poprzez kolejne wywołania operatora %.










===== Podstawowe przykłady =====

Aby skorzystać z biblioteki Boost Format należy przede wszystkim dołączyć nagłówek boost/format.hpp. Nagłówek ten dostarcza nam do użycia klasę boost::format posiadającą cztery konstruktory:

<code cpp>
format(const charT* str);
format(const charT* str, const std::locale & loc);
format(const string_t& s);
format(const string_t& s, const std::locale & loc);
</code>

Myślę, że komentarz tutaj jest zbędny. Jako pierwszy argument przekazujemy oczywiście łańcuch formatujący. Oto kilka najprostszych przykładów użycia:

<code cpp>
#include <iostream>
#include <boost/format.hpp>

// (...)

boost::format frm("Abc %1% %2% %3% %4% cbA"); // Tworzymy nowy obiekt
frm % "A";                                    // Przypisujemy pierwszy argument
frm % "B" % "C" % "D";                        // Kolejne argumenty przypisujemy za jednym zamachem
std::cout << frm << std::endl;                // --> "Abc A B C D cbA"
</code>

Wszystkie operacje możemy oczywiście wykonać w jednej linii. Liczba argumentów przekazywanych do obiektu jest dowolna, a każdy argument może wystąpić w przekazywanym łańcuchu dowolną ilość razy.
<code cpp>
std::cout << boost::format("%1% %2% %1%") % "A" % "B" << std::endl;  // --> "A B A"
</code>

Sformatowany string możemy także pobrać do zmiennej:
<code cpp>
std::string s = frm.str();         // Odpowiednia liczba argumentów musi być uprzednio przekazana do obiektu
std::string s2 = boost::str(frm); 
</code>

Tego samego obiektu format możemy użyć ile razy chcemy, dostarczając nowego zestawu argumentów.
<code cpp>
boost::format frm("%% _%1%_ _%2%_ _%3%_ %%");  // Podwójne użycie znaku specjalnego % spowoduje jego wypisanie na ekran
frm % "A" % 2.32 % 10;
std::cout << frm << std::endl;                 // --> "% _A_ _2.32_ _10_ %" 
frm % "Foo" % 2 % "Bar";
std::cout << frm << std::endl;                 // --> "% _Foo_ _2_ _Bar_ %"
</code>







===== Formatowanie argumentów =====

Na wstępie należałoby zaznaczyć, że argumenty w łańcuchu formatującym mogą być definiowane na trzy różne sposoby:
  - Odziedziczony po funkcji printf format: ''%spec''
  - ''%|spec|'' z nawiasami użytymi w celu dopuszczenia parametry ''type-char'' jako opcjonalny
  - ''%N%'' - prosty, przejrzysty sposób bez żadnego formatowania.

gdzie spec ma następującą składnie:

''[ N$ ] [ flags ] [ width ] [ .precision ] type-char''

Argumenty ujęte w nawiasy kwadratowe są opcjonalne, a dla typu drugiego (%|spec|) również ''type-char''.

Znaczenie poszczególnych parametrów:
  * N - numer argumentu
  * flags - jedna lub więcej spośród flag:
    * '-' - wyrównuje wynikowy łańcuch do lewej strony (ma sens przy jednoczesnym użyciu parametru ''width''
    * '=' - centruje wynikowy łańcuch (sens w przypadku jak wyżej)
    * '_' - wyrównuje wynikowy łańcuch do prawej strony
    * '+' - włącza wyświetlanie znaku także liczb dodatnich
    * '#' - włącza wyświetlanie bazy liczby (np. ''0x'' dla heksadecymalnych) oraz przecinek oddzielający część dziesiętną
    * '0' - wypełnia puste miejsca zerami
    * ' ' - poprzedza wynikowy łańcuch dodatkową spacją, jeśli nie jest wyświetlany minus ani plus.
  * width - wymuszenie minimalnej szerokości
  * precision - ilość cyfr po przecinku dla np trybu naukowego (type-char = e) lub ilość cyfr w ogóle dla np trybu general (type-char = g)
  * type-char - typ formatowania (jest to tylko sugestia typu, jeśli formatowanie nie powiedzie się, zostanie użyty inny domyślny typ):
    * p lub x - heksadecymalny
    * o - ósemkowy
    * e - naukowy
    * f - zmiennoprzecinkowy
    * g - ogólny (domyślny)
    * X, E or G - tak samo jak w przypadku x, e i g, ale wyświetla duże litery
    * d, i or u - dziesiętny
    * s or S - łańcuch znaków
    * c or C - jeden znak

Przykłady użycia poszczególnych formatowań pokazane są w poniższym kodzie:
<code cpp>
//TODO
</code>

W jednym łańcuchu możemy korzystać z różnych sposóbów, natomiast błędem jest użycie zarówno argumentów numerowanych, jak i nienumerowanych.
<code cpp>
std::cout << boost::format("%d %s") % 10 % "foo" << std::endl;         // OK
std::cout << boost::format("%1$s %2$s") % "foo" % "bar" << std::endl;  // OK
std::cout << boost::format("%1$d %s") % 10 % "bar" << std::endl;       // BŁĄD!
</code>

Inne sposoby modyfikacji formatowania parametrów:
<code cpp>
//TODO
</code>

===== Wyjątki i ich konfiguracja =====


===== Ciekawe przykłady użycia =====
zpr c++ quick reference

Narzędzia użytkownika

Narzędzia witryny

Narzędzia strony
