zpr c++ quick reference

/* * Autor: Piotr Buczkowski, 192902, N1-ISIII2 * * Temat: boost::type_traits * * Opis dotyczy biblioteki w wersji 1.38 * * Biblioteka „boost::type_traits” zawiera zbiór specyficznych klas cech, * z których każda obejmuje pojedynczą cechę systemu C++. * Na przykład czy dany typ jest wskaźnikiem czy referencją? * Lub czy typ posiada konstruktor domyślny albo kwalifikator „const”? * * Klas „type_traits” używamy ich w programowaniu generycznym * do określenia właściwości danego typu i optymalizacji * odpowiednich dla danego przypadku. * * Biblioteka „type_traits” zawiera także zbiór klas * dokonujących specyficznych transformacji na danym typie. * Potrafią na przykład usunąć kwalifikator „const” lub „volatile”. * Każda klasa dokonująca transformacji definiuje * wewnętrzny składnik „type” będący typem transformacji. * */

---

/* * Szablon „integral_constant” jest w hierarchii dziedziczenia * przodkiem klas „true_type” oraz „false_type” */ template <class T, T val> struct integral_constant {

typedef integral_constant<T, val> type;
typedef T value_type;
static const T value = val;

};

/* * Klasy „type_traits” mają wspólną cechę: * każda dziedziczy po „true_type” jeśli ma określoną właściwość * lub po „false_type” w przeciwnym wypadku. * Tak więc: * „true_type” jest typem oznaczającym, że klasa posiada daną cechę * „false_type” jest typem oznaczającym, że klasa danej cechy nie posiada */ typedef integral_constant<bool, true> true_type; typedef integral_constant<bool, false> false_type;

/* * Rozważmy najprostszą klasę w bibliotece: „is_void<T>”. * Dziedziczy ona po „true_type” tylko jeśli jako typ „T” podamy „void”. * Mówimy, że klasa szablonowa „is_void” dostarcza pełnej specjalizacji * (full-specialization), gdy typ „T” to „void”. Jest to dość ważna technika, * ale czasem potrzebujemy czegoś pomiędzy rozwiązaniem generycznym * a pełną specjalizacją. To dlatego komitet standaryzacyjny zdefiniował * częściową specjalizację (partial template-class specialization). */ template <typename T> struct is_void : public false_type{};

template <> struct is_void<void> : public true_type{};

/* * Kolejny przykład to klasa „is_pointer<T>”. * Głowna wersja obsługuje przypadki gdy „T” nie jest wskaźnikiem, * a częściowa specjalizacja w przeciwnym razie. */ template <typename T> struct is_pointer : public false_type{};

template <typename T> struct is_pointer<T*> : public true_type{};

/* * Generalnie obowiązuje zasada, że aby napisać częściową specjalizację * należy uprzednio napisać główną wersję. */

/* * Przyjrzyjmy się przykładowi pokazującemu sposób w jaki klasy cech mogą być użyte. * Pokazuje on w jaki sposób klasy cech mogą być użyte * do podjęcia decyzji o optymalizacji w czasie kompilacji. * Rozważmy algorytm kopiujący z biblioteki standardowej: */ template <typename Iter1, typename Iter2> Iter2 copy(Iter1 first, Iter1 last, Iter2 out); /* * W pewnych okolicznościach kopiowanie może być przeprowadzone najefektywniej * z użyciem funkcji „memcpy”, ale by tak uczynić spełnione muszą być następujące warunki: * - operator przypisania nie został zdefiniowany przez programistę * - brak składników będących referencjami * - wszystkie klasy bazowe oraz składniki klasy muszą mieć trywialny operator przypisania * * Biblioteka „type_traits” dostarcza klasę „has_trivial_assignment” taką, * że „has_trivial_assignment<T>::type” ma wartość „true” tylko wtedy, * gdy typ „T” ma trywialny operator przypisania. */ /* * Rozważmy następujący przykład: */ namespace detail {

/*
 * Szablon funkcji robiącej wolną, ale bezpieczną kopię.
 */
template<typename I1, typename I2, bool b>
I2 do_copy(I1 first, I1 last, I2 out, const integral_constant<bool, b>&)
{
   while(first != last)
   {
	  *out = *first;
	  ++out;
	  ++first;
   }
   return out;
}

/*
 * W tej wersji funkcji kopiującej wymagamy,
 * aby oba iteratory wskazywały na ten sam typ
 * oraz by ostatni parametr był typu "true_type".
 */
template<typename T>
T* do_copy(const T* first, const T* last, T* out, const true_type&)
{
   memcpy(out, first, (last-first)*sizeof(T));
   return out+(last-first);
}

}

/* * W tej wersji funkcji kopiującej posługujemy się funkcją „do_copy” * przekazując jej informację o typie wartości wskazywanych * przy użyciu „has_trivial_assign<value_type>”. * Spowoduje to wybranie wersji funkcji „do_copy” z „memcpy” * tylko tam gdzie tego chcemy * (czyli jedynie dla typów posiadających trywialny operator przypisania) * lub wersji wolniejszej lecz bezpiecznej w przeciwnym przypadku. */ template<typename I1, typename I2> inline I2 copy(I1 first, I1 last, I2 out) {

 /*
  * Kopiujemy przy użyciu "memcpy" jeżeli "T" ma trywialny operator przypisania
* oraz jeśli argumentami są wskaźniki.
  */
 typedef typename std::iterator_traits<I1>::value_type value_type;
 return detail::copy_imp(first, last, out, boost::has_trivial_assign<value_type>());

}

/* * W następnym przykładzie rozważmy prostą parę dwóch typów: */ template <typename T1, typename T2> struct pair {

T1 first;
T2 second;

/*
 * Ta prosta para nie może przechowywać referencji,
 * gdyż konstruktor musiałby przyjmować wtedy referencje do referencji.
 */
pair(const T1& nfirst, const T2& nsecond) : first(nfirst), second(nsecond) {}

}; /* * Aby zaradzić powyższemu problemowi posłużymy się klasą „add_reference”, * która dodaje referencję do typu nie-referencyjnego. */ #include <boost/type_traits/add_reference.hpp> template <typename T1, typename T2> struct improved_pair {

T1 first;
T2 second;

improved_pair(boost::add_reference<const T1>::type nfirst,
	boost::add_reference<const T2>::type nsecond) :
		first(nfirst), second(nsecond) {}

};

/* * Powyższe przykłady demonstrowały ideę klas cech * oraz to w jaki sposób mogą one zostać użyte. * Kompletnej listy dostępnych klas należy szukać w dokumentacji „boost”. */