C++ templates
Синтаксис
template < typename T >
void f(const T& value)
{
std::cout << "Value is: " << value << std::endl;
}
template < typename T, size_t n >
struct Array
{
T data[n];
};
Примеры использования
template < typename T >
class auto_ptr
{
typedef auto_ptr MyType;
T* _ptr;
auto_ptr(const MyType& other);
MyType& operator = (const MyType& other);
public:
auto_ptr(T* const ptr) : _ptr(ptr) { }
~auto_ptr() { delete _ptr; }
T& operator *() const { return *_ptr; }
T* operator ->() const { return _ptr; }
};
Примеры использования
struct A
{
int a;
};
int main()
{
auto_ptr<A> p_a = new A;
(*p_a).a = 9;
int i = p_a->a;
return 0;
}
smart pointers
• std::auto_ptr – лучше не использовать
• _com_ptr_t – для COM-интерфейсов
• boost::scoped_ptr – некопируемый
• boost::shared_ptr – копируемый, использует подсчёт ссылок
• boost::weak_ptr – решает проблему «кольцевых ссылок»
boost:: scoped_ptr
template<class T> class scoped_ptr // noncopyable
{
T * ptr;
scoped_ptr(scoped_ptr const &); // prohibited
scoped_ptr & operator=(scoped_ptr const &); // prohibited
void operator==( scoped_ptr const& ) const; // prohibited
void operator!=( scoped_ptr const& ) const; // prohibited
public:
explicit scoped_ptr(T * p = 0); // never throws
explicit scoped_ptr(std::auto_ptr<T> p); // never throws
~scoped_ptr(); // never throws
T & operator*() const; // never throws
T * operator->() const; // never throws
operator bool () const; // never throws
bool operator! () const; // never throws
T * get() const; // never throws
void reset(T * p = 0); // never throws
void swap(scoped_ptr & b); // never throws
};
std::auto_ptr
template < class _Ty > class auto_ptr
{
public:
template<class _Other> operator auto_ptr<_Other>()
{ return (auto_ptr<_Other>(*this)); }
template<class _Other> auto_ptr<_Ty>& operator = (auto_ptr<_Other>& _Right)
{ reset(_Right.release()); return (*this); }
template<class _Other> auto_ptr(auto_ptr<_Other>& _Right) : _Myptr(_Right.release())
{}
_Ty *release()
{
_Ty *_Tmp = (_Ty *)_Myptr;
_Myptr = 0;
return (_Tmp);
}
...
};
Недостатки глобальных переменных
• Объекты создаются всегда, даже если они не
используются
• Порядок инициализации в общем случае
неизвестен
• Объекты не разрушаются до завершения
программы
• Проблемы с исключениями в конструкторах
объектов
Singleton
template < typename T >
class Singleton
{
public:
static T& Instance()
{
static T instance;
return instance;
}
static const T& ConstInstance()
{
return const_cast<const T&>(Instance());
}
};
Singleton
class A
{
private:
friend class Singleton<A>;
A() {}
public:
int a;
};
int main()
{
Singleton<A>::Instance().a = 3;
std::cout << Singleton<A>::ConstInstance().a << std::endl;
return 0;
}
Частичная специализация шаблонов
template < typename T >
T MaxValue();
template < >
int MaxValue<int>()
{ return INT_MAX; }
template < >
float MaxValue<float>()
{ return FLT_MAX; }
int main()
{
std::cout << "Max int value = " << MaxValue<int>() << std::endl;
std::cout << "Max float value = " << MaxValue<float>() << std::endl;
return 0;
}
Compile time check
template <bool b> struct CompileTimeError;
template <> struct CompileTimeError<true>{};
CompileTimeError<2 == 4> ERROR_assert_failed;
#define STATIC_CHECK(expr, msg) \
{ CompileTimeError<expr> ERROR_##msg; (void)ERROR_##msg; }
int main()
{
STATIC_CHECK(2 == 5, assert_failed)
return 0;
}
Шаблонные шаблонные параметры
template < typename T, template <typename> class Creator = NewCreator >
class Singleton
{
public:
typedef T* InstancePtr;
private:
static InstancePtr _instancePtr;
static void Destroy(void)
{ if(_instancePtr != NULL) Creator<T>::Destroy(_instancePtr); }
public:
static T& Instance()
{
if(_instancePtr == NULL)
{ _instancePtr = Creator<T>::Create(); atexit(&Singleton::Destroy); }
return *_instancePtr;
}
};
template < typename T, template <typename> class C>
typename Singleton<T, C>::InstancePtr Singleton<T, C>::_instancePtr = NULL;
Шаблонные шаблонные параметры
template <class T> struct MallocCreator
{
static T* Create()
{
void* p = std::malloc(sizeof(T));
if (!p) return 0;
return new(p) T;
}
static void Destroy(T* p)
{ p->~T(); std::free(p); }
};
template <class T> struct NewCreator
{
static T* Create() { return new T; }
static void Destroy(T* p) { delete p; }
};
Недостатки указателей на функции
• Нет информации о типах аргументов и
возвращаемого значения
• Указатель на функцию необходимо перед
вызовом проверять на NULL
• Есть возможность привести указатель на
функцию к любому указателю
• Разный синтаксис вызова для указателей на
функции и указателей на методы
Функторы, простая реализация
template < typename Signature >
class function;
template < typename R, typename P >
class function < R (P) >
{
typedef function MyType;
typedef R (*Signature)(P);
Signature _func;
MyType& operator = (const MyType&);
public:
function(Signature func) : _func(func) { }
function(const MyType& other): _func(other._func) { }
R operator () (P p)
{ return _func(p); }
};
Функторы, простая реализация
template <typename ObjType, typename R, typename P1, typename P2>
class function < R (ObjType::*) (P1, P2) >
{
typedef function MyType;
typedef R (ObjType::*Signature)(P1, P2);
Signature _func;
MyType& operator = (const MyType&);
public:
function(Signature func) : _func(func) { }
function(const MyType& other): _func(other._func) { }
R operator () (ObjType& obj, P1 p1, P2 p2)
{ return (obj.*_func)(p1, p2); }
};
Функторы, простая реализация
struct A
{
char C;
A(char c = ‘X') : C(c) { }
void member_func(double i, bool b)
{ if (b) std::cout << C << i << std::endl; }
};
int main()
{
A a;
function< void (A::*)(double, bool) > f(&A::member_func);
f(a, 0.5, true);
function < int (int) > f2(&abs);
std::cout << f2(-123) << std::endl;
return 0;
}
Функторы STL
int main()
{
A a;
std::mem_fun1_t< void, A, double > f = std::mem_fun(&A::member_func);
f(&a, 0.5);
std::mem_fun1_ref_t < void, A, double > f_ref =
std::mem_fun_ref(&A::member_func);
f_ref(a, 0.7);
std::pointer_to_unary_function<int, int> f2 = std::ptr_fun(&abs);
std::cout << f2(-123) << std::endl;
return 0;
}
Недостатки функторов STL
• Уродливый синтаксис
• Отсутствие функторов с большим количеством
параметров
• Отсутствует возможность инициализации
функтора с сигнатурой func1 указателем на func2:
struct B : public A{};
void func1(B*);
void func2(A*);
boost::function
int main()
{
A a;
boost::function < void (A&, double) > f =
&A::member_func;
f(a, 0.5);
boost::function < int (int) > f2 = &abs;
std::cout << f2(-123) << std::endl;
return 0;
}
Применение функторов
void generate_int(int& i)
{ i = rand() % 100 - 50; }
void print_int(int i)
{ std::cout << i << " "; }
int main()
{
std::vector<int> vec(10);
std::for_each(vec.begin(), vec.end(), &generate_int);
std::for_each(vec.begin(), vec.end(), &print_int);
std::cout << std::endl;
std::vector<int> out_vec;
std::transform(vec.begin(), vec.end(), std::back_inserter(out_vec), &abs);
std::for_each(out_vec.begin(), out_vec.end(), &print_int);
std::cout << std::endl;
return 0;
}
Привязывание параметров
int main()
{
std::vector<int> vec(10);
std::for_each(vec.begin(), vec.end(), &generate_int);
std::for_each(vec.begin(), vec.end(), &print_int);
std::cout << std::endl;
vec.erase( std::remove_if(vec.begin(), vec.end(),
std::bind1st(std::less<int>(), 10)), vec.end() );
std::for_each(vec.begin(), vec.end(), &print_int);
std::cout << std::endl;
return 0;
}
Недостатки std::bind1st/2nd
•
•
•
•
Работают только для binary_function
Привязывают только один аргумент
Неудобный синтаксис
Нет возможности привязать ссылку:
void inc (int& n, bool) { ++n; }
// ...
std::bind1st(std::ptr_fun(&inc), i) (true);
boost::bind
bool in_range( int min_val, int max_val, int val )
{ return (val >= min_val) && (val <= max_val); }
int main()
{
// ...
boost::function < bool(int) > pred = boost::bind(&in_range, 5, 15, _1);
vec.erase( std::remove_if(vec.begin(), vec.end(), pred), vec.end() );
// ...
return 0;
}
“Подводные камни” boost::bind
class WindowBase
{
typedef boost::function < void (void) > EventHandler;
EventHandler _onPaint;
protected:
WindowBase(const EventHandler& onPaint) : _onPaint(onPaint) { }
// ...
};
struct MyWindow : public WindowBase
{
MyWindow() : WindowBase(boost::bind(&MyWindow::OnPaint, this)) { }
void OnPaint() { }
};
MyWindow CreateMyGreatWindow()
{ return MyWindow(); }
int main()
{
MyWindow wnd = CreateMyGreatWindow();
return 0;
}
Преимущества использования
шаблонов C++
• Шаблоны решают проблему дублирования
кода
• Зачастую шаблоны позволяют избавиться от
динамической диспечеризации и повысить
скорость работы приложения
• Позволяют отследить большую часть ошибок
на этапе компиляции
• Использование стратегий позволяет не писать
сложные классы с нуля, а собирать их из
множества меньших
• Можно грабить корованы
Список литературы
•
•
•
•
•
•
•
•
Бьерн Страуструп. Язык программирования С++
Скотт Мейерс. Эффективное использование С++
Скотт Мейерс. Наиболее эффективное использование С++
Скотт Мейерс. Эффективное использование STL
Герб Саттер. Решение сложных задач на C++
Герб Саттер. Новые сложные задачи на C++
Андрей Александреску. Современное проектирование на C++
Герб Саттер. Андрей Александреску. Стандарты
программирования на С++. 101 правило и рекомендация
• Владимир Сорокин. Голубое сало.