++iter;
return *this;
}
insert_iterator‹Container›& operator*() {return *this;}
insert_iterator‹Container›& operator++() {return *this;}
insert_iterator‹Container›& operator++(int) {return *this;}
};
template ‹class Container, class Iterator›
insert_iterator<Container› inserter(Container& x, Iterator i) {
return insert_iterator‹Container›(x, Container::iterator(i));
}
Адаптеры функций (Function adaptors)
Функциональные адаптеры работают только с классами функциональных объектов с определёнными типами параметров и типом результата.
Отрицатели not1 и not2 берут унарный и бинарный предикаты соответственно и возвращают их дополнения.
template ‹class Predicate›
class unary_negate: public unary_function‹Predicate::argument_type, bool› {
protected:
Predicate pred;
public:
unary_negate(const Predicate& x): pred(x) {}
bool operator()(const argument_type& x) const {return !pred(x);}
};
template ‹class Predicate›
unary_negate‹Predicate› not1(const Predicate& pred) {
return unary_negate‹Predicate›(pred);
}
template ‹class Predicate›
class binary_negate: public binary_function‹Predicate::first_argument_type, Predicate::second_argument_type, bool› {
protected:
Predicate pred;
public:
binary_negate(const Predicate& x): pred(x) {}
bool operator()(const first_argument_type& x, const second_argument_type& y) const {
return !pred(x, y);
}
};
template ‹class Predicate›
binary_negate‹Predicate› not2(const Predicate& pred) {
return binary_negate‹Predicate›(pred);
}
Привязки bind1st и bind2nd берут функциональный объект f двух параметров и значение x и возвращают функциональный объект одного параметра, созданный из f с первым или вторым параметром соответственно, связанным с х.
template ‹class Predicate›
class binder1st: public unary_function {
protected:
Operation op;
Operation::first_argument_type value;
public:
binder1st(const Operation& x, const Operation::first_argument_type& y) : op(x), value(y) {}
result_type operator()(const argument_type& x) const {
return op(value, x);
}
};
template ‹class Operation, class T›
binder1st‹Operation› bind1st(const Operation& op, const T& x) {
return binder1st‹Operation›(op, Operation::first_argument_type(x));
}
template ‹class Operation›
class binder2nd: public unary_function‹0peration::first_argument_type, Operation::result_type› {
protected:
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.
#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;
}
#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;
return 0;
}
#include ‹stl.h›
#include ‹iostream.h›
#include ‹string.h›
bool str_equal(const char* a_, const char* b_) {
return ::strcmp(a_, b_) == 0 ? 1:0;
}
char* grades[] = {"A", "B", "C", "D", "F"};
char* letters[] = {"Q", "E", "D"};
int main() {
const unsigned gradeCount = sizeof(grades) / sizeof(grades[0]);
const unsigned letterCount = sizeof(letters) / sizeof(letters[0]);
ostream_iterator ‹char*› iter(cout, " ");
cout ‹‹ "grades: ";
copy(grades, grades + gradeCount, iter);
cout ‹‹ "nletters:";
copy(letters, letters + letterCount, iter);
cout ‹‹ endl;
char** location = search(grades, grades + gradeCount, letters, letters + letterCount, str_equal);
if (location == grades + gradeCount) cout ‹‹ "letters not found in grades" ‹‹ endl;
else cout ‹‹ "letters found in grades at offset: " ‹‹ location - grades ‹‹ endl;
copy(grades + 1, grades + 1 + letterCount, letters);
cout ‹‹ "grades: ";
copy(grades, grades + gradeCount, iter);
cout ‹‹ "nletters:";
copy(letters, letters + letterCount, iter);
cout ‹‹ endl;
location = search(grades, grades + gradeCount, letters, letters + letterCount, str_equal);
if (location == grades + gradeCount) cout ‹‹ "letters not found in grades" ‹‹ endl;
else cout ‹‹ "letters found in grades at offset: " ‹‹ location - grades ‹‹ endl;
return 0;
}
#include ‹stl.h›
#include ‹iostream.h›
#include ‹string.h›
bool compare_strings(const char* s1_, const char* s2_) {
return ::strcmp(s1_, s2_) ‹ 0 ? 1: 0;
}
char* names[] = {"Todd", "Mike", "Graham", "Jack", "Brett"};
int main() {
