An overview of Standard C++ TR1

S G Ganesh

09/06/08 2

Agenda

Introduction to TR1 Utility Classes Containers Function Objects Type Traits Numerics Regular Expressions C-compatibility Compilers/Library Vendors Supporting TR1

09/06/08 3

Introduction To TR1

TR1 - "Technical Report 1” New functionality added to C++ Standard Library Provided in std::tr1 namespace Not part of the C++ Standard (yet) Most of the vendors don’t support it (yet) Most of the TR1 components from Boost Only essential components are included

Fills gaps left in the standard library not “less important”, “interesting” or “curious” components

Expanded toolkit - many useful reusable components Helps you to be more productive

Helps you avoid reinventing the wheel

09/06/08 4

Utilities – shared_ptr

tr1::shared_ptr smart pointer for shared memory resource Automates resource(memory) deallocation Not a scoped pointer like std::auto_ptr

Can be copied freely Can be used in containers

Reference counted Overhead involved as need to maintain a counter Circular references are a trouble (they won’t be freed)

• Use tr1::weak_ptr for that tr1::shared_ptr complements std::auto_ptr

09/06/08 5

Shared_ptr - Example#include <tr1/shared_ptr>#include <vector>#include <iostream>

using namespace std; using namespace std::tr1;

struct Object { Object(int val) { mem = val; cout << "Creating Object" << mem; } ~Object() { cout << "Destroying Object" << mem; } int mem;};

int main() { typedef shared_ptr<Object> ObjectPtr; vector<ObjectPtr> SmartVector; SmartVector.push_back(ObjectPtr(new Object(1))); SmartVector.push_back(ObjectPtr(new Object(2)));}// prints: Creating Object1 Creating Object2

Destroying Object1 Destroying Object2

09/06/08 6

Utilities – Tuple

Generalization of the template std::pair std::pair is for two types, tr1::tuple is for N types

N can be up to 10 or more make_tuple, that creates a tuple object

similar to make_pair However syntax of tuple is different that of pair

since first and second doesn’t scale so, use function template get<n> instead

Useful for: Eliminating boilerplate container classes Particularly useful for multiple returning values from a

function Storing more than one object in a container

09/06/08 7

tuple - Example#include <tr1/tuple> #include <iostream>

using namespace std; using namespace tr1; using namespace tr1::tuples;

tuple<char, int, float> tuple_creator() { return make_tuple ('b', 3, 3.0f); }

int main() { tuple<char, int, float> my_tuple ('1', 1, 1.0f); get<0>(my_tuple) = 'a'; get<1>(my_tuple) = 2; get<2>(my_tuple) = 2.0f;

cout << set_open('{') << set_delimiter('-') << set_close('}') << my_tuple << tuple_creator() << endl;

} // prints: {a-2-2} {b-3-3}

09/06/08 8

Containers

Hurray, at last, we have Hash maps! Standard associative containers are ordered

(typically implemented as RB trees) Accessing an element is slower

Unordered associative containers is a dire need Hashmaps promise constant time for element access tr1::unordered_set, tr1::unordered_multiset, tr1::

unordered_map, tr1::unordered_multimap Might have better naming convention

but “unordered” instead of “hash” abstracts implementation details

09/06/08 9

Containers – Array

Fixed Size Container Use when you know how many objects you need

Satisfies requirements for a sequence container

iterators, front(), back(), size() … So you can use them with standard algorithms

Safe to pass/return them in functions easily and safely C style arrays error prone and strict no no!

Use tr1::array instead if no need to interface with legacy code

09/06/08 10

Containers – Array - Example#include <tr1/array> #include <iostream>using namespace std;

int main() { typedef tr1::array<double, 5> dbl_fixed_array; dbl_fixed_array my_array;

dbl_fixed_array::iterator itr = my_array.begin(); while(itr != my_array.end()) *itr++ = 3.0;

for(int i = 0; i < my_array.size(); i++) cout << my_array[i];

// prints 3 3 3 3 3 }

09/06/08 11

Function Objects

Four New Function Objects Named Function Objects

tr1::reference_wrapper and tr1::function Unnamed Function Objects

Produced by calls to tr1::mem_fn and tr1::bind

09/06/08 12

Function Objects - reference_wrapper Wrapper type that acts like a reference

object But unlike references, tr1::reference_wrapper

objects can be copied and assigned to ref(x) creates an tr1::reference_wrapper<T> object

• where T is type of x Use cref(x) for creating tr1::reference_wrapper<const

T>

09/06/08 13

Function Objects – reference_wrapper - Example

#include <boost/ref.hpp>#include <functional>#include <iostream>

using namespace boost;using namespace std;

struct functor { int operator()(int x, int y) { return x * y; };};

template <class Func>void apply(Func func, int arg1, int arg2) { cout << func(arg1, arg2); }

int main() { reference_wrapper<functor > rw1 = ref(functor()); apply<functor>(rw1, 10, 20); reference_wrapper<multiplies<int> > rw3 = ref(multiplies<int>()); apply<multiplies<int> >(rw3, 10, 20);}

09/06/08 14

Function Objects - function Wrapper type for a type that has function call operator

e.g. function<int (int, float)> This refers to a type with function call operator which can take

an int and a float and return an int Store any function-like ‘thing’: functions, member functions,

functors First-class objects: Easily pass them to functions or copy

Powerful because it can abstract object of any type that which has a function call operator of specific arguments

and return types Store an action

Call at any time; change at any time Implementation of the GoF Command pattern

09/06/08 15

Function Objects – function - Example

#include <tr1/function.hpp> #include <iostream>

using namespace std; using namespace std::tr1;

struct mul_functor { float operator()(int x, int y) const { return ((float) x) * y; }; };

void call(function<float (int, int)> &f, int x, int y) { cout << f(x, y); }

int main() { function<float (int, int)> func; func = mul_functor(); call(func, 100, 200); }// prints: 20000

09/06/08 16

Function Objects – mem_fn and bind

Produced by calls to tr1::mem_fn and tr1::bind tr1::mem_fn

generalized wrapper for pointer to functions first argument is the object on which call is done

can be an object, a reference, a pointer, or a smart pointer! remaining are named arguments to the member function

tr1::bind generalization of std::bind1st and std::bind2nd

Why unnamed function objects? specifies template functions that return objects of these new

types because we use these as function objects that we pass to

template functions

09/06/08 17

Function Objects – mem_fn - Example

#include <tr1/function>#include <tr1/shared_ptr>#include <iostream>#include <memory>

using namespace tr1; using namespace std;

struct some_struct { void print() { cout << "some_struct::print "; } };

template <class function>void call(function fn) { // call through call wrapper fn(new some_struct());

fn(shared_ptr<some_struct>(new some_struct())); fn(shared_ptr<some_struct>(new some_struct()).get()); }

int main() { call(mem_fn(&some_struct::print));

// prints: some_struct::print some_struct::print some_struct::print}

09/06/08 18

Function Objects – bind - Example#include <tr1/bind>#include <iostream>

using namespace std; using namespace tr1;

template <class Binder>void show(Binder binder) { int i = 5; int j = 10; binder(i, j);}

void print(int t) { cout << t << '\t'; }

int main() { show(bind(print, 0)); show(bind(print, _1)); show(bind(print, _2));} // prints: 0 5 10

09/06/08 19

Type Traits Useful for template programming

instead of knowing nothing about the magic type “T” passed as type parameter in a template

provides a set of “type predicates” can do “type transformations” when we have knowledge

about what exactly is the type “T” in a template Template meta-programming

Like it or not, template meta-programming is getting wide attention

many of the things that can be done with type traits can also be done with function overloading

but typetraits simplify things and makes meta-programming easier

09/06/08 20

Type Traits - Example#include <tr1/type_traits>#include <cstring>#include <iostream>

using namespace std;using namespace tr1;

struct do_copy { template<typename T> static void exec(T* dest, T* src, int num) { if(!is_pod<T>::value) { for(int i=0; i<num; ++i) *dest++ = *src++; } else memcpy(dest, src, sizeof(T)*num ); }};

09/06/08 21

Type Traits – Example continuedstruct S {

S& operator = (const S &s) { cout << "copying S"<< endl; return s; } };

int main() { do_copy c; S * sarr1 = new S[3]; S sarr2[3]; char str1[6] = "hello"; char str2[6] = "world"; c.exec(str2, str1, sizeof(str1)); cout << str2; c.exec(sarr2, sarr1, 3);}// prints: hello

copying S copying S

copying S

09/06/08 22

Numerics

Mathematical special functions twenty-three functions

float, double, and long double overloads

Engineering and scientific computing becomes easier No reinventing the wheel/no writing of textbook code For established and widely used functionality (in specific

domains) e.g: cylindrical Bessel functions, confluent hypergeometric functions

Four random number generators and nine types of binomial distributions

You can combine those generators and distributions

09/06/08 23

Regular Expressions

Finally we have pattern matching capabilities Powerful search and replace features

use tr1::regex to store a regular expression pass the tr1::regex object to tr1::regex_match, tr1::

regex_search, or tr1::regex_replace Templated thingy, so not limited to searching

standard strings Perl can no more boast that it’s the best Use iterators to step through the

subsequences/matches for the regular expression

09/06/08 24

Regular Expressions - Example#include <tr1/regex> #include <iostream> using namespace std; using namespace tr1;

int main() { //regex_merge example const string one("tr1 "); const regex two("stuff is "); const string three(“cool"); cout << regex_merge(one, two, three); // prints: tr1 stuff is cool

// regex_match example const string good_str (“4323-4342"); const string bad_str (“645433-323"); const regex match_expr("(\\d{4}-\\d{4})");

cout<< boolalpha << regex_match(good_str, match_expr) << regex_match(bad_str, match_expr) << endl; // prints: true false

}

09/06/08 25

C Compatibility TR1 adopts the changes in C standard

C++ standard is based on 1990 C standard C standard amended in 1995; revised in 1999 (C99)

Adopted features from C standard Low-level control of floating point operations Several new functions from C standard library fixed width integral types new format specifiers for printf/scanf family

New argument matching rules for math functions as in C standard Currently ambiguous: for call to atan2(flt, dbl), atan2(float,

float), atan2(double, double), and atan2(long double, long double) equally good matches

Under new rules atan2(double, double) is the best match

09/06/08 26

Compilers/Vendors Supporting TR1

Dinkumware (www.dinkumware.com) first commerical library vendor to provide TR1 (as part of the

Dinkum C++ Library) Boost (www.boost.org)

Many of the components of TR1 from Boost library A separate download package of TR1 components already

available Project GNU (www.gnu.org)

Parts of TR1 in their C++ Standard Library Can be used with g++

HP aCC RogueWave doesn’t provide TR1 yet Testing of Boost TR1/aCC planned

with sample programs, the components seem to work fine

09/06/08 27

Wrapping Up

Links The standard committee document on TR1

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf The Boost TR1

http://freespace.virgin.net/boost.regex/tr1/index.html

Q & A Thank You!