Introduction à C++ 2011 (C++0x)

#include <iostream>

int main() {
    int tableau[5] = {1, 2, 3, 4, 5};
    for(int &x : tableau) {
        std::cout << x << std::endl;
    }
    return 0;
}

enum Direction { HAUT, DROITE, BAS, GAUCHE };

Direction direction = HAUT;

std::cout << direction << std::endl;

std::cout << static_cast<int>(direction) << std::endl;

enum class Direction { Haut, Droite, Bas, Gauche };

Direction direction = Direction::Haut;

std::cout << direction << std::endl;

std::cout << static_cast<int>(direction) << std::endl;

int nombre = 5 + Direction::Droite;

std::vector<std::vector<int> > nombres;

std::vector<std::vector<int>> nombres;

std::vector<int> nombres;
nombres.push_back(1);
nombres.push_back(2);
nombres.push_back(3);
nombres.push_back(4);
nombres.push_back(5);

std::vector<int> nombres = { 1, 2, 3, 4, 5 };

int nombres2[] = { 1, 2, 3, 4, 5 };

#include <iostream>
#include <map>
#include <ostream>
#include <string>

int main() {
    std::map<int, std::string> nombres = { { 1, "un" }, { 2, "deux" }, { 3, "trois" } };
    std::cout << nombres[1] << std::endl;
}

int main() {
    afficherListe({ 1, 2, 3, 4, 5 });
    return 0;
}

void afficherListe(std::initializer_list<int> liste) {
    //Affichage de la liste.
}

void afficherListe(std::initializer_list<int> liste) {
    for(std::initializer_list<int>::iterator i(liste.begin()) ; i != liste.end() ; ++i) {
        std::cout << *i << std::endl;
    }
}

#include <initializer_list>

auto nombre = 5;

for(auto i(nombres.begin()) ; i != nombres.end() ; ++i) {
    std::cout << *i << std::endl;
}

for(std::vector<int>::iterator i(nombres.begin()) ; i != nombres.end() ; ++i) {
    std::cout << *i << std::endl;
}

typedef std::vector<int>::iterator iter_entier;
for(iter_entier i(nombres.begin()) ; i != nombres.end() ; ++i) {
    std::cout << *i << std::endl;
}

auto variable = 5;
decltype(variable) autreVariable;

#include <iostream>

template <typename T>
T maximum(const T& a, const T& b) {
    if(a > b) {
        return a;
    }
    else {
        return b;
    }
}

template <typename T>
T minimum(const T& a, const T& b) {
    if(a < b) {
        return a;
    }
    else {
        return b;
    }
}

int main() {
    int a(10), b(20);
    auto plusGrand = maximum(a, b);
    decltype(plusGrand) plusPetit = minimum(a, b);
    std::cout << "Le plus grand est : " << plusGrand << std::endl;
    std::cout << "Le plus petit est : " << plusPetit << std::endl;
    return 0;
}

double a(10.5), b(20.5);

int ajouterDixPourcents(int nombre) {
    if(nombre + 10 <= 100) {
        return nombre + 10;
    }
    else {
        return 100;
    }
}

float ajouterDixPourcents(float nombre) {
    if(nombre + 0.1 <= 1) {
        return nombre + 0.1;
    }
    else {
        return 1;
    }
}

template <typename T> auto ajouter(T nombre) -> decltype(ajouterDixPourcents(nombre)) {
    return ajouterDixPourcents(nombre);
}

int main() {
    int pourcentageEntier(42);
    float pourcentageFlottant = pourcentageEntier / 100.f;
    std::cout << pourcentageFlottant << " = " << pourcentageEntier << "%" << std::endl;
    
    pourcentageEntier = ajouter(pourcentageEntier);
    pourcentageFlottant = ajouter(pourcentageFlottant);
    std::cout << pourcentageFlottant << " = " << pourcentageEntier << "%" << std::endl;
}

auto cinq() -> int {
    return 5;
}

-> type

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

void afficherElement(int element) {
    cout << element << endl;
}

int main() {
    vector<int> nombres = { 1, 2, 3, 4, 5 };
    for_each(nombres.begin(), nombres.end(), afficherElement);
    
    return 0;
}

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> nombres = { 1, 2, 3, 4, 5 };
    for(int &element : nombres) {
        cout << element << endl;
    }
    
    return 0;
}

for(int &element : nombres)

for(int &element : nombres) {
    ++element;
}

map<int, string> nombres = { { 1, "un" }, { 2, "deux" }, { 3, "trois" } };
for(auto i : nombres) {
    cout << i.first << " => " << i.second << endl;
}

int *pointeur(0);

int *pointeur(nullptr);

int nul = NULL;

int nul = nullptr;

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<int> nombres = { 1, 2, 3, 4, 5 };
    for_each(nombres.begin(), nombres.end(), [](int element) {
        cout << element << endl;
    });
    
    return 0;
}

[](int element) {
    cout << element << endl;
}

std::function<int (int, int)> addition = [](int x, int y) -> int {
    return x + y;
};

auto addition = [](int x, int y) -> int {
    return x + y;
};

[](int x, int y) -> int {
    return x + y;
}

[&somme](std::vector<int> vecteur {
    //...
}

[x](int &a) {
    a = x;
}

int somme(0);
std::function<void (std::vector<int>)> sommeVecteur = [&somme](std::vector<int> vecteur) {
    for(int &x : vecteur) {
        somme += x;
    }
};

std::vector<int> nombres = { 1, 2, 3, 4, 5 };

sommeVecteur(nombres);
std::cout << somme << std::endl;

int x(10);
auto afficherVariableX = [x]() {
    std::cout << x << std::endl;
};

afficherVariableX();

int tableauFixe[5];

#include <array>

std::array<int, 5> tableauFixe;

std::array<int, 5> tableauFixe = { 1, 2, 3, 4, 5 };

int taille = 5;
std::array<int, taille> tableauFixe = { 1, 2, 3, 4, 5 };

int const taille = 5;
std::array<int, taille> tableauFixe = { 1, 2, 3, 4, 5 };

for(int nombre : tableauFixe) {
    std::cout << nombre << std::endl;
}

tableauFixe[0] = 10;
tableauFixe.at(1) = 40;
std::cout << tableauFixe[1] << std::endl;
std::cout << tableauFixe.at(0) << std::endl;

#include <array>
#include <iostream>

int main() {
    std::array<int, 5> tableauFixe = { 1, 2, 3, 4, 5 }; //Création d’un tableau à taille fixe de cinq entiers.
    
    //Affichage de tous ses éléments.
    for(int nombre : tableauFixe) {
        std::cout << nombre << std::endl;
    }
    
    std::cout << "Taille : " << tableauFixe.size() << std::endl; //Affichage de sa taille.
    
    //Modification d’éléments.
    tableauFixe[0] = 10;
    tableauFixe.at(1) = 40;
    std::cout << tableauFixe[1] << std::endl; //Affichage d’un élément précis sans vérification de limite.
    std::cout << tableauFixe.at(0) << std::endl; //Même chose sauf qu’il y a une vérification de limite.
    std::cout << tableauFixe.front() << std::endl; //Afficher le premier élément.
    std::cout << tableauFixe.back() << std::endl; //Afficher le dernier élément.
    
    if(not tableauFixe.empty()) {
        std::cout << "Le tableau n’est pas vide." << std::endl;
    }
    
    tableauFixe.fill(5); //Modifier tous les éléments pour la valeur 5.
    
    for(std::array<int, 5>::iterator i(tableauFixe.begin()) ; i != tableauFixe.end() ; ++i) {
        std::cout << *i << std::endl;
    }
    return 0;
}

#include <tuple>

std::tuple<int, double, std::string> nomTuple;

std::tuple<int, double, std::string> personne(22, 185.4, "Jack");

std::get<0>(personne) = 23;

std::cout << "Âge : " << std::get<0>(personne) << std::endl;

#include <iostream>
#include <string>
#include <tuple>

int main() {
    std::tuple<int, double, std::string> personne(22, 185.4, "Jack"); //Création d’un tuple.
    std::get<0>(personne) = 23; //Modification d’un objet d’un tuple.
    
    //Affichage des objets du tuple.
    std::cout << "Âge : " << std::get<0>(personne) << std::endl << "Taille : " << std::get<1>(personne) << std::endl << "Prénom : " << std::get<2>(personne) << std::endl;
    
    typedef std::tuple<int, double, std::string> tuple_personne;
    std::cout << "Taille du tuple : " << std::tuple_size<tuple_personne>::value << std::endl; //Affichage de la taille du tuple.
    tuple_personne jack(23, 185.4, "Jack");
    if(personne == jack) { //Comparaison de tuples.
        std::cout << "Les tuples sont identiques." << std::endl;
    }
    return 0;
}

#include <chrono>

std::chrono::time_point<std::chrono::system_clock> temps = std::chrono::system_clock::now();

auto temps = std::chrono::system_clock::now();

#include <chrono>
#include <iostream>

int main() {
    auto temps1 = std::chrono::system_clock::now();
    usleep(100000);
    auto temps2 = std::chrono::system_clock::now();
    
    std::cout << (temps2 - temps1).count() << " microsecondes." << std::endl;
    
    return 0;
}

std::chrono::nanoseconds nbrNanoSecondes = (temps2 - temps1);
std::cout << nbrNanoSecondes.count() << " nanosecondes." << std::endl;

std::chrono::duration<double, std::milli> nbrMilliSecondes = (temps2 - temps1);
std::cout << nbrMilliSecondes.count() << " millisecondes." << std::endl;

typedef duration<int64_t, nano> 	nanoseconds;

std::chrono::duration<double, std::ratio<1>> nbrSecondes = (temps2 - temps1);

std::chrono::duration<double> nbrSecondes = (temps2 - temps1);

struct Paire {
    int nombre1;
    int nombre2;
};

int main() {
    Paire paire{ 5, 25 }; //Initialise nombre1 à 5 et nombre2 à 25.
    return 0;
}

paire = { 3, 9 };

Paire getPaire() {
    return { 10, 100 }; //Retourne une Paire dont nombre1 = 10 et nombre2 = 100.
}

paire = getPaire();

#include <iostream>

class Paire {
    public:
        Paire(int nombre1, int nombre2) : nombre1_(nombre1), nombre2_(nombre2) {}
        
    private:
        int nombre1_;
        int nombre2_;
};

Paire getPaire() {
    return { 10, 100 }; //Retourne une Paire dont nombre1_ = 10 et nombre2_ = 100.
}

int main() {
    Paire paire{ 5, 25 }; //Initialise nombre1_ à 5 et nombre2_ à 25.
    paire = { 3, 9 };
    paire = getPaire();
    return 0;
}

Paire(std::initializer_list<int> liste) : nombre1_(*liste.begin()), nombre2_(*liste.end()) {
    std::cout << "Liste d’initialisateurs." << std::endl;
}

bool booleen{false};
int nombre{42};
int tableau[5] = { 1, 2, 3, 4, 5 };
std::vector<int> vecteurNombres{ 1, 2, 3 };
std::string chaine{"Hello World!"};
int* pointeurSurEntier{nullptr};