2. C++ Avancé

2.11. Nouvelles fonctionnalités du C++11

La version C++11 apporte de nouvelles fonctionnalités.

Pour pouvoir les utiliser il faut compiler avec l'option -std=c++11 sous gcc/g++ 4.7 et supérieures.

2.11.1. Alias de namespace

Alias d'espace de nom permet de créer un raccourci pour décrire un espace de nom plus complexe /

CODE
alias_namespace.cpp

// compile with -std=c++11
#include <iostream>
#include <string>
#include <memory> // for unique_ptr
#include <unordered_map>
#include <string>
 
// ------------------------------------
// 1. type definition
// ------------------------------------
typedef
    std::unique_ptr<std::unordered_map<std::string, std::string>>
    UPtrMapSS;
    
// or
 
using UPtrMapSS =
    std::unique_ptr<std::unordered_map<std::string, std::string>>;
 
// ------------------------------------
// 2. function pointer
// ------------------------------------
typedef void (*FP)(int, const std::string&);
 
using FP = void (*)(int, const std::string&);
 
 
// ------------------------------------
// 3. namespaces
// ------------------------------------
 
namespace bio {
    namespace phylo {
         namespace parsimony {
             int my_constant = 1234;
         }
    }
}
 
namespace pars = bio::phylo::parsimony;
 
// ------------------------------------
// main
// ------------------------------------
int main() {
    std::cout << pars::my_constant;
    std::cout << " or " <<  bio::phylo::parsimony::my_constant << '\n';
}
 
 
    
 

2.11.2. Initialisation {} et ()

Qu'est ce qui distingue les 4 initialisations suivantes ?

int x(0); 
int y = 0; 
int z{ 0 }; 
int z = { 0 };

Afin d'éviter la confusion, C++11 introduit l'initialisation uniforme qui utilise les accolades, on parle également de braced initialization (based on braces) :

2.11.3. L'instruction for in

Une nouvelle syntaxe pour l'instruction for a été introduite et permet de réaliser une énumération sur un conteneur de la STL :

CODE
for_in.cpp

// use g++ -std=c++11 to compile
 
#include <vector>
#include <iostream>
using namespace std;
 
int main() {
 
    vector<int> vect;
 
    for (int i= 0; i < 10; ++i) vect.push_back(i);
 
    int sum1 = 0;
    for (int v : vect) {
        sum1 += v;
    }
 
    // or
    int sum2 = 0;
    for (int i=0; i<vect.size(); ++i) {
        sum2 += vect[i];
    }
 
    // or
    int sum3 = 0;
    vector<int>::iterator it;
    for (it = vect.begin(); it != vect.end(); ++it) {
        sum3 += (*it);
    }
    
    cout << "sum1 = " << sum1 << endl;
    cout << "sum2 = " << sum2 << endl;
    cout << "sum3 = " << sum3 << endl;
    return EXIT_SUCCESS;
}
 

2.11.4. Les améliorations liées à la déclaration de type

C++11 introduit deux qualificateurs/déclarateurs de type :

auto : permet de ne pas déclarer le type d'une variable qui sera déduit par le compilateur
decltype : permet de déclarer le type d'une nouvelle variable en fonction du type d'une variable existante

CODE
decl_type.cpp

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
 
 
int main() {
    vector<int> v1(20);
    
    srand(19702013);
    
    generate(v1.begin(), v1.end(), [](){ return rand() % 20; });
    
    // use of auto
    // auto will deduce vector<int>::iterator
    for (auto it = v1.begin(); it != v1.end(); ++it) {
        cout << (*it) << " ";
    }
    cout << endl;
    
    // USE of decltype
    // declare v2 of type v1 and set v2 = v1;
    decltype(v1) v2 = v1;
    transform(v2.begin(), v2.end(), v2.begin(), [](int x) { return x*x; });
    
    // USE of for in
    // print v2 using for in
    for (int x : v2) {
        cout << x << " ";
    }
    cout << endl;
    
    return 0;
}
 

Attention en C++14 on peut utiliser decltype(auto) pour définir par exemple le type de retour d'une fonction.

2.11.5. emplace_back + move au lieu de push_back

Le C++11 introduit une nouvelle fonctionnalité emplace_back qui permet de créer à la volée un élément et de l'insérer dans un vecteur par exemple. Cette fonctionnalité est intéressante dans le cas d'un vector<T> où T est un type défini par l'utilisateur.

Avec un push_back on est contraint de créer une instance de T puis d'en créer une copie. Avec emplace_back on ne crée qu'une seule instance, il faut alors définir un constructor de type move.

CODE
emplace_back.cpp

#include <vector>
#include <string>
#include <iostream>
using namespace std;
 
class Person1 {
public:
    string name;
    int age;
 
    Person1() {
        cout << "default constructor Person1" << endl;
        name = "unknown";
        age = -1;
    }
    
    Person1(string n, int a) : name(n), age(a) {
        cout << "construct Person1" << endl;
    }
    
    Person1(const Person1& p) {
        cout << "copy constructor Person1" << endl;
        name = p.name;
        age = p.age;
    }
        
    Person1& operator=(const Person1& p) {
        name = p.name;
        age = p.age;
        cout << "assign Person1" << endl;       
    }
    
    friend ostream& operator<<(ostream& out, Person1& p) {
        cout << p.name << ", " << p.age;
    }
};
 
void test1() {
    vector<Person1> v;
    cout << endl << "PUSH BACK" << endl;
    cout << string(40, '-') << endl;
    cout << "- push back" << endl;
    v.push_back(Person1("Masha", 5));
}
 
 
class Person2 {
protected:
    string name;
    int age;
 
public: 
    Person2(string n, int a) : name(n), age(a) {
        cout << "construct Person2 { " << name << ", " << age << " }" << endl;
    }
 
    /**
     * introduction of a move constructor and use of std::move()
     */    
    Person2(Person2&& p) : name(std::move(p.name)), age(p.age) {
        cout << "move Person2  { " << name << ", " << age << " }" << endl;
    }
    
    Person2& operator=(const Person2& p) {
        name = p.name;
        age = p.age;
        cout << "assign Person2  { " << name << ", " << age << " }" << endl;        
    }
 
};
 
void test2() {
    vector<Person2> v;
    cout << endl << "EMPLACE BACK" << endl;
    cout << string(40, '-') << endl;
    v.emplace_back(Person2("Masha", 5));
    
}
 
/**
 * main function
 */ 
int main() {
    test1();
    test2();
    
    return EXIT_SUCCESS;
}
 

PUSH BACK
----------------------------------------
- push back
construct Person1
copy constructor Person1

EMPLACE BACK
----------------------------------------
construct Person2 { Masha, 5 }
move Person2  { Masha, 5 }

2.11.6. Gestion des pointeurs

Deux classes existent qui permettent de manipuler des pointeurs et garantir leur valididté au cours de l'exécution d'un porogramme. Cela permet notamment d'éviter les fuites mémoires (memory leaks) :

unique_ptr<T> : gère un pointeur de manière à ce qu'il n'y ait qu'une seule occurrence valide
shared_ptr<T> : gère plusieurs pointeurs sur un même espace et libère l'espace quand il n'est plus référencé par aucun pointeur
existe également weak_ptr : a smart pointer that holds a non-owning ("weak") reference to an object that is managed by std::shared_ptr : en d'autres termes c'est un pointeur de type shared_ptr mais qui n'est pas pris en compte dans le nombre de références partagées

2.11.6.a Unique

CODE
unique_ptr.cpp

#include <iostream>
#include <memory>
using namespace std;
 
int main() {
    unique_ptr<int> p1(new int);
    
    *p1 = 2;
    cout << "p1 = " << *p1 << endl;
    
    // will produce double free or corruption (fasttop) error
    // unique_ptr<int> p2(p1.get());
    
    // use move() to transfer the pointer to a new reference
    unique_ptr<int> p2(std::move(p1));
    
    // will produce segmentation fault because owned by p1
    //cout << "p1 = " << *p1 << endl;
    
    *p2 = 7;
    cout << "p2 = " << *p2 << endl;
    
    // then go back to p1
    p1 = std::move(p2);
    cout << "p1 = " << *p1 << endl;
    
    return 0; 
}
 
 

p1 = 2
p2 = 7
p1 = 7

2.11.6.b Shared

CODE
shared_ptr.cpp

#include <iostream>
#include <memory>
#include <algorithm>
#include <vector>
using namespace std;
 
// ===============================================================
// class used for example purpose and that holds one integer value
// ===============================================================
class A {
protected:
    int value;
public:
    // default constructor
    A() : value(-1) {
        cout << "A::default constructor" << endl;
    }
    // constructor with value
    A(int v) : value(v) {
        cout << "A::constructor with value" << endl;
    }
    // destructor
    ~A() {
        cout << "A::destructor" << endl;
    }
    // redefinition of operator() to access value
    int& operator()(void) {
        return value;
    }
    
    // getter
    int get() { return value; }
    
    // setter
    void set(int v) { value = v; }
    
    operator int() const { return value; }
    
};
 
 
 
// ===============================================================
// example with pointer that refer to one pointer to integer
// we create three shared pointers that are released at the
// end of the subprogram
// ===============================================================
void use_shared_ptr_with_int() {
    
    cout << "======================================" << endl;
    cout << " integers" << endl;
    cout << "======================================" << endl;
    
    shared_ptr<int> p1(new int);
    shared_ptr<int> p2(p1);
    shared_ptr<int> p3(p1);
    
    *p1 = 1;
    *p2 = 2;
    *p3 = 3;
    
    // print number of references to array of integers
    cout << "int is referenced " << p1.use_count() << " time(s)" << endl;
 
}
 
// ===============================================================
// example with array of integers
// we create one shared_ptr that contains a pointer to an array
// of 10 integers
// ===============================================================
void use_shared_ptr_with_int_array() {
    
    cout << "======================================" << endl;
    cout << " array of integers" << endl;
    cout << "======================================" << endl;
    
    // it is necessary to redefine the destructor as a lambda function
    shared_ptr<int> p1(new int[10], [](int *tab) { delete [] tab; } );
        
    // assign each element to a value   
    for (int i=0; i<10; ++i) {
        (static_cast<int *>(p1.get())[i]) = i;
    }
 
    // declare another reference to p1
    shared_ptr<int> p2(p1);
        
    // replace each element by its square value using p2    
    transform(&static_cast<int *>(p2.get())[0], 
        &static_cast<int *>(p2.get())[10], 
        &static_cast<int *>(p2.get())[0], 
        [](int n) { return n*n; });
    
    
    // print each value using p1 (or p2)
    for (int i=0; i<10; ++i) {
        cout << static_cast<int *>(p1.get())[i] << " ";
    }   
    cout << endl;
    
    // print number of references to array of integers
    cout << "Array is referenced " << p1.use_count() << " time(s)" << endl;
    
    // remove reference of p1
    p1 = nullptr;
    
    // print number of references to array of integers
    cout << "Array is referenced " << p2.use_count() << " time(s)" << endl;
}
 
// ===============================================================
// example with array of class instance
// we create one shared_ptr that contains a pointer to an array
// of 10 instances of class A
// ===============================================================
void use_shared_ptr_with_class_array() {
 
    cout << "======================================" << endl;
    cout << " array of class A" << endl;
    cout << "======================================" << endl;
    
    // it is necessary to redefine the destructor as a lambda function
    shared_ptr<A> p1(new A[10], [](A *tab) { delete [] tab; } );
        
    // assign a value to each element using the operator()  
    for (int i=0; i<10; ++i) {
        (static_cast<A *>(p1.get())[i])() = i;
    }
    
    // print value of each element using p1 and operator ()
    for (int i=0; i<10; ++i) {
        cout << (static_cast<A *>(p1.get())[i])() << " ";
    }
    cout << endl;
 
    // declare another reference to p1
    shared_ptr<A> p2(p1);
        
    // replace each value by its square value using p2 and get/set  
    for_each(&static_cast<A *>(p2.get())[0], 
        &static_cast<A *>(p2.get())[10], 
         [](A& obj) -> void { obj.set( obj.get() * obj.get()); });
         
    // replace each value by its square value using p2 and operator()   
    for_each(&static_cast<A *>(p2.get())[0], 
        &static_cast<A *>(p2.get())[10], 
         [](A& obj) -> void { obj() = obj() * obj(); });
         
    
    // print each element using p1 (or p2) and operator int
    for (int i=0; i<10; ++i) {
        cout << static_cast<int>(static_cast<A *>(p1.get())[i]) << " ";
    }   
    cout << endl;
    
    // print number of references to array of integers
    cout << "Array is referenced " << p1.use_count() << " time(s)" << endl;
    
    // remove reference of p1
    p1 = nullptr;
    
    // print number of references to array of integers
    cout << "Array is referenced " << p2.use_count() << " time(s)" << endl;
    
}
 
// =================
// main function
// =================
int main() {
    use_shared_ptr_with_int();
    use_shared_ptr_with_int_array();
    use_shared_ptr_with_class_array();
    return 0;
}   
    
 

======================================
 integers
======================================
int is referenced 3 time(s)
======================================
 array of integers
======================================
0 1 4 9 16 25 36 49 64 81 
Array is referenced 2 time(s)
Array is referenced 1 time(s)
======================================
 array of class A
======================================
A::default constructor
A::default constructor
A::default constructor
A::default constructor
A::default constructor
A::default constructor
A::default constructor
A::default constructor
A::default constructor
A::default constructor
0 1 2 3 4 5 6 7 8 9 
0 1 16 81 256 625 1296 2401 4096 6561 
Array is referenced 2 time(s)
Array is referenced 1 time(s)
A::destructor
A::destructor
A::destructor
A::destructor
A::destructor
A::destructor
A::destructor
A::destructor
A::destructor
A::destructor

L'utilisation de valgrind permet de vérifier l'absence de fuite mémoire :

\$ valgrind ./c2_shared_ptr.exe
==3476== Memcheck, a memory error detector
==3476== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==3476== Using Valgrind-3.10.0.SVN and LibVEX; rerun with -h for copyright info
==3476== Command: ./c2_shared_ptr.exe
==3476==
...
==3476== 
==3476== HEAP SUMMARY:
==3476==     in use at exit: 0 bytes in 0 blocks
==3476==   total heap usage: 6 allocs, 6 frees, 180 bytes allocated
==3476== 
==3476== All heap blocks were freed -- no leaks are possible
==3476== 
==3476== For counts of detected and suppressed errors, rerun with: -v
==3476== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Voici un autre exemple à tester :

CODE
valgrind_example.cpp

#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;
 
char *str;
int *arr;
float *tab;
 
/**
 * allocate resources
 */
void allocate_data() {
    str = new char [100];
    arr = (int *) malloc(100 * sizeof(int));
    tab = new float[10];
}
 
/**
 * free resources
 */
void free_data() {
    // should be delete [] str
    delete str;
    // should be free(arr);
    delete [] arr;
    // forget to free tab
}
 
int main() {
    allocate_data();
    
    strcpy(str, "toto");
    // use more elements than allocated
    for (int i=0; i<101; ++i) {
        arr[i] = i;
    }
    
    free_data();
    
    exit(EXIT_SUCCESS);
}
 
/**
 * valgrind -v --leak-check=summary --log-file=a.txt ./valgrind_example.exe
 * valgrind -v --tool=cachegrind --log-file=a.txt ./valgrind_example.exe
 *
 */
 
/*
==6354== Invalid write of size 4
==6354==    at 0x4008D7: main (valgrind_example.cpp:36)
==6354==  Address 0x5a1c280 is 0 bytes after a block of size 400 alloc'd
==6354==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40084E: allocate_data() (valgrind_example.cpp:15)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
--6354-- REDIR: 0x4e940f0 (operator delete(void*)) redirected to 0x4c2c250 (operator delete(void*))
==6354== Mismatched free() / delete / delete []
==6354==    at 0x4C2C2BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40087B: free_data() (valgrind_example.cpp:24)
==6354==    by 0x4008E7: main (valgrind_example.cpp:39)
==6354==  Address 0x5a1c040 is 0 bytes inside a block of size 100 alloc'd
==6354==    at 0x4C2B800: operator new[](unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.
so)
==6354==    by 0x40083A: allocate_data() (valgrind_example.cpp:14)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
--6354-- REDIR: 0x4e94120 (operator delete[](void*)) redirected to 0x4c2c7d0 (operator delete[](void*))
==6354== Mismatched free() / delete / delete []
==6354==    at 0x4C2C83C: operator delete[](void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x400896: free_data() (valgrind_example.cpp:26)
==6354==    by 0x4008E7: main (valgrind_example.cpp:39)
==6354==  Address 0x5a1c0f0 is 0 bytes inside a block of size 400 alloc'd
==6354==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40084E: allocate_data() (valgrind_example.cpp:15)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
--6354-- REDIR: 0x51bddf0 (free) redirected to 0x4c2bd80 (free)
==6354== 
==6354== HEAP SUMMARY:
==6354==     in use at exit: 40 bytes in 1 blocks
==6354==   total heap usage: 3 allocs, 2 frees, 540 bytes allocated
==6354== 
==6354== Searching for pointers to 1 not-freed blocks
==6354== Checked 193,168 bytes
==6354== 
==6354== LEAK SUMMARY:
==6354==    definitely lost: 0 bytes in 0 blocks
==6354==    indirectly lost: 0 bytes in 0 blocks
==6354==      possibly lost: 0 bytes in 0 blocks
==6354==    still reachable: 40 bytes in 1 blocks
==6354==         suppressed: 0 bytes in 0 blocks
==6354== Rerun with --leak-check=full to see details of leaked memory
==6354== 
==6354== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
==6354== 
==6354== 1 errors in context 1 of 3:
==6354== Mismatched free() / delete / delete []
==6354==    at 0x4C2C83C: operator delete[](void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x400896: free_data() (valgrind_example.cpp:26)
==6354==    by 0x4008E7: main (valgrind_example.cpp:39)
==6354==  Address 0x5a1c0f0 is 0 bytes inside a block of size 400 alloc'd
==6354==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40084E: allocate_data() (valgrind_example.cpp:15)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
==6354== 
==6354== 1 errors in context 2 of 3:
==6354== Mismatched free() / delete / delete []
==6354==    at 0x4C2C2BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40087B: free_data() (valgrind_example.cpp:24)
==6354==    by 0x4008E7: main (valgrind_example.cpp:39)
==6354==  Address 0x5a1c040 is 0 bytes inside a block of size 100 alloc'd
==6354==    at 0x4C2B800: operator new[](unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40083A: allocate_data() (valgrind_example.cpp:14)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
==6354== 
==6354== 1 errors in context 3 of 3:
==6354== Invalid write of size 4
==6354==    at 0x4008D7: main (valgrind_example.cpp:36)
==6354==  Address 0x5a1c280 is 0 bytes after a block of size 400 alloc'd
==6354==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40084E: allocate_data() (valgrind_example.cpp:15)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
==6354== ERROR SUMMARY: 3 errors from 3 contexts (suppressed: 0 from 0)
 
 
 
 
*/
 
 

\$ valgrind -v --leak-check=summary --log-file=a.txt ./valgrind_example.exe
\$ cat a.txt

==6354== Invalid write of size 4
==6354==    at 0x4008D7: main (valgrind_example.cpp:36)
==6354==  Address 0x5a1c280 is 0 bytes after a block of size 400 alloc'd
==6354==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40084E: allocate_data() (valgrind_example.cpp:15)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
--6354-- REDIR: 0x4e940f0 (operator delete(void*)) redirected to 0x4c2c250 (operator delete(void*))
==6354== Mismatched free() / delete / delete []
==6354==    at 0x4C2C2BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40087B: free_data() (valgrind_example.cpp:24)
==6354==    by 0x4008E7: main (valgrind_example.cpp:39)
==6354==  Address 0x5a1c040 is 0 bytes inside a block of size 100 alloc'd
==6354==    at 0x4C2B800: operator new[](unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40083A: allocate_data() (valgrind_example.cpp:14)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
--6354-- REDIR: 0x4e94120 (operator delete[](void*)) redirected to 0x4c2c7d0 (operator delete[](void*))
==6354== Mismatched free() / delete / delete []
==6354==    at 0x4C2C83C: operator delete[](void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x400896: free_data() (valgrind_example.cpp:26)
==6354==    by 0x4008E7: main (valgrind_example.cpp:39)
==6354==  Address 0x5a1c0f0 is 0 bytes inside a block of size 400 alloc'd
==6354==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6354==    by 0x40084E: allocate_data() (valgrind_example.cpp:15)
==6354==    by 0x4008A5: main (valgrind_example.cpp:31)
==6354== 
--6354-- REDIR: 0x51bddf0 (free) redirected to 0x4c2bd80 (free)
==6354== 
==6354== HEAP SUMMARY:
==6354==     in use at exit: 40 bytes in 1 blocks
==6354==   total heap usage: 3 allocs, 2 frees, 540 bytes allocated
==6354== 
==6354== Searching for pointers to 1 not-freed blocks
==6354== Checked 193,168 bytes
==6354== 
==6354== LEAK SUMMARY:
==6354==    definitely lost: 0 bytes in 0 blocks
==6354==    indirectly lost: 0 bytes in 0 blocks
==6354==      possibly lost: 0 bytes in 0 blocks
==6354==    still reachable: 40 bytes in 1 blocks
==6354==         suppressed: 0 bytes in 0 block

2.11.7. Ratio

2.11.8. Gestion du temps

C++11 introduit plusieurs fonctionnalités pour gérer le temps :

Voici une version d'un chronomètre lisible difficilement :

CODE
chrono_v1.cpp

#include <chrono>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <typeinfo>
using namespace std;
 
 
template <typename V, typename R>
ostream& operator << (ostream& s, const chrono::duration<V,R>& d) {
   s << "[" << d.count() << " of " << R::num << "/"
                                   << R::den << "]";
   return s;
}
 
class Chrono {
protected:
    std::chrono::time_point<std::chrono::high_resolution_clock> t_start, t_stop;
    
public:
    Chrono() {
        t_stop = t_start = std::chrono::high_resolution_clock::now();
    }
    void start() {
        t_stop = t_start = std::chrono::high_resolution_clock::now();
    }
    void stop() {
        t_stop = std::chrono::high_resolution_clock::now();
    }
    
    ostream& print(ostream& out) {
        auto ms = t_stop - t_start;
        std::chrono::hours   hh = std::chrono::duration_cast<std::chrono::hours>(ms);
        std::chrono::minutes mm = std::chrono::duration_cast<std::chrono::minutes>(ms % chrono::hours(1));
        std::chrono::seconds ss = std::chrono::duration_cast<std::chrono::seconds>(ms % chrono::minutes(1));
        std::chrono::milliseconds msec = std::chrono::duration_cast<std::chrono::milliseconds>(ms % chrono::seconds(1)); 
        out << setfill('0') << setw(2) << hh.count() << "::"
            << setw(2) << mm.count() << "::"
            << setw(2) << ss.count() << "::"
            << setw(3) << msec.count();
        return out;
    }
    
    ostream& print_raw(ostream& out) {
        auto ms = t_stop - t_start;
        std::chrono::hours   hh = std::chrono::duration_cast<std::chrono::hours>(ms);
        std::chrono::minutes mm = std::chrono::duration_cast<std::chrono::minutes>(ms % chrono::hours(1));
        std::chrono::seconds ss = std::chrono::duration_cast<std::chrono::seconds>(ms % chrono::minutes(1));
        std::chrono::milliseconds msec = std::chrono::duration_cast<std::chrono::milliseconds>(ms % chrono::seconds(1)); 
        std::cout <<  hh << "::" << mm << "::" << ss << "::" << msec << endl;
        return out;
    }
    
    
    friend ostream& operator<<(ostream& out, Chrono& c) {
        return c.print(out);
    }
    
 
};
 
int main()  {
    Chrono chrono;
    
    chrono.start();
    
    for (int r=0; r<700;++r) {
        float sum = 0.0;
        for (int i=0; i<1000000; ++i) {
            sum += sqrt(i);
        }
    }
    
    chrono.stop();
    cout << "duration=" << chrono << endl;
    cout << "duration raw = ";
    chrono.print_raw(cout);
    cout << endl;  
    
    return 0;
}
 

Ainsi qu'une version un peu plus lisible qui utilise l'alias de namespace :

CODE
chrono_v2.cpp

#include <chrono>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <typeinfo>
using namespace std;
 
namespace SC = std::chrono;
 
template <typename V, typename R>
ostream& operator << (ostream& s, const chrono::duration<V,R>& d) {
   s << "[" << d.count() << " of " << R::num << "/"
                                   << R::den << "]";
   return s;
}
 
class Chrono {
protected:
    typedef SC::time_point<SC::high_resolution_clock> Time;
     
    Time t_start, t_stop;
    
public:
    Chrono() {
        t_stop = t_start = SC::high_resolution_clock::now();
    }
    void start() {
        t_stop = t_start = SC::high_resolution_clock::now();
    }
    void stop() {
        t_stop = SC::high_resolution_clock::now();
    }
    
    ostream& print(ostream& out) {
        auto ms = t_stop - t_start;
        SC::hours   hh = SC::duration_cast<SC::hours>(ms);
        SC::minutes mm = SC::duration_cast<SC::minutes>(ms % chrono::hours(1));
        SC::seconds ss = SC::duration_cast<SC::seconds>(ms % chrono::minutes(1));
        SC::milliseconds msec = SC::duration_cast<SC::milliseconds>(ms % chrono::seconds(1)); 
        out << setfill('0') << setw(2) << hh.count() << "::"
            << setw(2) << mm.count() << "::"
            << setw(2) << ss.count() << "::"
            << setw(3) << msec.count();
        return out;
    }
    
    ostream& print_raw(ostream& out) {
        auto ms = t_stop - t_start;
        SC::hours   hh = SC::duration_cast<SC::hours>(ms);
        SC::minutes mm = SC::duration_cast<SC::minutes>(ms % chrono::hours(1));
        SC::seconds ss = SC::duration_cast<SC::seconds>(ms % chrono::minutes(1));
        SC::milliseconds msec = SC::duration_cast<SC::milliseconds>(ms % chrono::seconds(1)); 
        std::cout <<  hh << "::" << mm << "::" << ss << "::" << msec << endl;
        return out;
    }
    
    
    friend ostream& operator<<(ostream& out, Chrono& c) {
        return c.print(out);
    }
    
 
};
 
int main()  {
    Chrono chrono;
    
    chrono.start();
    
    for (int r=0; r<700;++r) {
        float sum = 0.0;
        for (int i=0; i<1000000; ++i) {
            sum += sqrt(i);
        }
    }
    
    chrono.stop();
    cout << "duration=" << chrono << endl;
    cout << "duration raw = ";
    chrono.print_raw(cout);
    cout << endl;  
    
    return 0;
}
 

# compilation sans optimisation
\$ g++ -o c2_chrono_v2.exe c2_chrono_v2.cpp -std=c++11 -lm
\$ ./c2_chrono_v2.exe 
duration=00::00::06::918
duration raw = [0 of 3600/1]::[0 of 60/1]::[6 of 1/1]::[918 of 1/1000]

# compilation avec optimisation -O2
\$ g++ -o c2_chrono_v2.exe c2_chrono_v2.cpp -std=c++11 -lm -O2
richer@thor:~/public_html/ens/inra$ ./c2_chrono_v2.exe 
duration=00::00::00::791
duration raw = [0 of 3600/1]::[0 of 60/1]::[0 of 1/1]::[791 of 1/1000]

2.11.9. Nombres aléatoires

C++11 introduit des classes pour la génération de nombres aléatoires ainsi que les traitements liés aux probabilités. Ces classes sont issues de boost.

Pour rappel une séquence de nombre aléatoires est obtenue par une formule de récurrence partant d'une valeur initiale appelée graine (ou seed en anglais).

La bibliothèque <random> introduit :

différents générateurs de nombres aléatoire : congruence linéaire, mersenne twister, soustraction avec retenue
ainsi que des distributions des nombres : uniforme (entier, réel), normale, bernouilli, binomiale, exponentielle, gamma, géométrique, gaussienne, de Poisson, Cauchy, Chi-squared

L'un des éléments importants d'un générateur est la période de la série de nombres générés. Celle ci doit être assez grande pour éviter d'obtenir les mêmes valeurs de manière répétitive. La fonction rand() du C utilise un générateur congruentiel linéaire qui est supposé de mauvaise qualité, on recommande d'utiliser par exemple un générateur de type mersenne twister.

C++11 introduit std::seed_seq pour encourage l'utilisation de meilleurs graines.

Voici un exemple simple pour générer des nombres aléatoires entiers avec distribution uniforme dans un intervalle donné :

CODE
random.cpp

#include <random>
#include <iostream>
#include <cstdlib>
#include <vector>
#include <map>
#include <iterator>
#include <algorithm>
#include <chrono>
using namespace std;
 
const int MAX_ITER = 10000;
const int MIN_VALUE = 1;
const int MAX_VALUE = 2;
 
vector<int> values;
 
void avg_std() {
    int sum = accumulate(values.begin(), values.end(), 0);
    double avg = static_cast<float>(sum) / values.size();
    
    double sq_sum = std::inner_product(values.begin(), values.end(), values.begin(), 0.0);
    double stdev = std::sqrt(sq_sum / values.size() - avg * avg);
    auto itmin = min_element(values.begin(), values.end());
    auto itmax = max_element(values.begin(), values.end());
    cout << "avg=" << avg  
        << ", std=" << stdev 
        << ", min=" << (*itmin)
        << ", max=" << (*itmax)
        << endl;
    map<int,int> count;
    for (auto x : values) {
        ++count[x];
    }   
    for (auto y : count) {
        cout << y.first <<": " << y.second << endl;
    }
}
 
// default rand function
void default_c() {
    srand(time(nullptr));
    for (int i=0; i<MAX_ITER; ++i) {
        values.push_back(MIN_VALUE + rand() % (MAX_VALUE - MIN_VALUE + 1));
    }
    avg_std();
}
 
// use of uniform distribution with default random engine
void default_random() {
    default_random_engine generator( time(nullptr) );
    uniform_int_distribution<int> distribution{MIN_VALUE, MAX_VALUE};
    
    values.clear();
    for (int i=0; i<MAX_ITER; ++i) values.push_back( distribution(generator) );
    avg_std();
}
 
// use of uniform distribution with Mersenne Twister
void mt19937_random() {
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
 
    mt19937 generator(seed); 
    uniform_int_distribution<int> distribution{MIN_VALUE, MAX_VALUE};
    
    values.clear();
    for (int i=0; i<MAX_ITER; ++i) values.push_back( distribution(generator) );
    avg_std(); 
}
 
int main() {
    default_c();
    default_random();
    mt19937_random();
    exit(EXIT_SUCCESS);
}
 

Un des résultats en sortie pour l'intervalle $[1,2]$ avec 10.000 valeurs générées est :

avg=1.4931, std=0.499952, min=1, max=2
1: 5069
2: 4931
avg=1.4957, std=0.499982, min=1, max=2
1: 5043
2: 4957
avg=1.5061, std=0.499963, min=1, max=2
1: 4939
2: 5061

Un des résultats en sortie pour l'intervalle $[1,100]$ avec 10.000 valeurs générées est :

avg=50.0572, std=28.7731, min=1, max=100
avg=50.0615, std=28.8766, min=1, max=100
avg=50.3719, std=28.905, min=1, max=100

Voir également l'article Random number generation using C++ TR1 de John D. Cook.

Page de Jean-Michel Richer