An Overview Of Standard C++ TR1
description
Transcript of An Overview Of Standard C++ TR1
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!