РУКОВОДСТВО ПО СТАНДАРТНОЙ БИБЛИОТЕКЕ ШАБЛОНОВ (STL)

 Operation op;
 Operation::second_argument_type value;
public:
 binder2nd(const Operation& x, const Operation::second_argument_type& y) : op(x), value(y) {}
 result_type operator(const argument_type& x) const {
 return op(x, value);
 }
};

template ‹class Operation, class T›
binder2nd‹Operation› bind2nd(const Operation& op, const T& x) {
 return binder2nd‹0peration›(op, Operation::second_argument_type(x));
}

Например, find_if(v.begin, v.end, bind2nd(greater‹int›, 5)) находит первое целое число в векторе v большее, чем 5; find_if(v.begin, v.end, bind1st(greater‹int›, 5)) находит первое целое число в v меньшее, чем 5.

Адаптеры указателей на функции (Adaptors for pointers to functions)

Чтобы позволить указателям на (унарные и бинарные) функции работать с функциональными адаптерами, библиотека обеспечивает следующее:

template ‹class Arg, class Result›
class pointer_to_unary_function: public unary_function‹Arg, Result› {
protected:
 Result (*ptr)(Arg);
public:
 pointer_to_unary_function {}
 pointer_to_unary_function(Result (*x)(Arg)): ptr(x) {}
 Result operator(Arg x) const {return ptr(x);}
};

template ‹class Arg, class Result›
pointer_to_unary_function‹Arg, Result› ptr_fun(Result (*x)(Arg)) {
 return pointer_to_unary_function‹Arg, Result›(x);
}

template
class pointer_to_binary_function: public binary_function {
protected:
 Result (*ptr)(Arg1, Arg2);
public:
 pointer_to_binary_function {}
 pointer_to_binary_function(Result (*x)(Arg1, Arg2)): ptr(х) {}
 Result operator(Arg1 x, Arg2 y) const {return ptr(x, y);}
};

template ‹class Arg1, class Arg2, class Result›
pointer_to_binary_function‹Arg1, Arg2, Result› ptr_fun(Result (*x)(Arg1, Arg2)) {
 return pointer_to_binary_function‹Argl, Arg2, Result›(x);
}

Например, replace_if(v.begin, v.end, not1(bind2nd(ptr_fun(strcmp), "C")), "C++") заменяет все "С" на "C++" в последовательности v.

Системы трансляции, которые имеют множественный указатель на типы функций, должны обеспечить дополнительные шаблоны функций ptr_fun.

Примитивы управления памятью (Memory Handling Primitives)

Чтобы получать типичный указатель на неинициализированный буфер памяти данного размера, определена следующая функция:

template ‹class T›
inline T* allocate(ptrdiff_t n, Т*); // n ›= 0

Размер (в байтах) распределённого буфера - не меньше n*sizeof(T).

Для каждой модели памяти имеется соответствующий шаблон функции allocate, определённый с типом первого параметра, являющимся типом расстояния указателей в модели памяти.

Например, если система трансляции поддерживает _huge указатели с типом расстояния long long, обеспечивается следующая шаблонная функция:

template ‹class T›
inline T _huge* allocate(long long n, T _huge *);

Также обеспечиваются следующие функции:

template ‹class T›
inline void deallocate(T* buffer);

template ‹class T1, class T2›
inline void construct(T1* p, const T2& value) {new (p) T1(value);}

template ‹class T›
inline void destroy(T* pointer) {pointer-›~T;}

deallocate освобождает буфер, выделенный allocate. Для каждой модели памяти имеются соответствующие шаблоны функций deallocate, construct и destroy, определённые с типом первого параметра, являющимся типом указателя в модели памяти.

template ‹class T›
pair‹T*, ptrdiff_t› get_temporary_buffer(ptrdiff_t n, T*);

template ‹class T›
void return_temporary_buffer(T* p);

get_temporary_buffer ищет наибольший буфер, не больше чем n*sizeof(T), и возвращает пару, состоящую из адреса и размера (в единицах sizeof(T)) буфера. return_temporary_buffer возвращает буфер, выделенный get_temporary_buffer.

ПРИМЕРЫ ПРОГРАММ С ШАБЛОНАМИ

Эти примеры демонстрируют использование нового продукта STL ‹ToolKit› от компании ObjectSpace. STL ‹ToolKit› - это самый простой способ использования STL, который работает на большинстве комбинаций платформ/компиляторов, включая cfront, Borland, Visual C++, Set C++, ObjectCenter и последние компиляторы от Sun&HP.

accum1.cpp

#include ‹ospace/stl.h›
#include ‹iostream.h›

int main {
 vector‹int› v(5);
 for (int i = 0; i ‹ v.size; i++) v[i] = i + 1;
 int sum = accumulate(v.begin, v.end, 0);
 cout ‹‹ "sum = " ‹‹ sum ‹‹ endl;
 return 0;
}

accum2.cpp

#include ‹stl.h›
#include ‹iostream.h›

int mult(int initial_, int element_) {
 return initial_ * element_;
}

int main {
 vector‹int› v(5);
 for (int i = 0; i ‹ v.size; i++) v[i] = i + 1;
 int prod = accumulate(v.begin, v.end, 1, mult);
 cout ‹‹ "prod = " ‹‹ prod ‹‹ endl;