C++0x - Premiers pas

Aucun doute n'est plus permis, le x est un nombre hexadécimal!

Mais trêves de finasseries, j'ai fini par installer g++ 4.5 pour essayer un peu les nouvelles fonctionnalités. Je m'inquiétais un petit peu de devenir un dinosaure du C++ et de ressentir une méfiance instinctive, mais de fait j'ai plutôt envie de les utiliser le plus vite possible!

Ma fonctionnalité préférée est sans doute les lambdas, dont le plus simple exemple est probablement celui-là:

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

int main()
{
 std::vector<std::string> v;
 v.push_back("a");
 v.push_back("b");
 v.push_back("c");
 std::for_each(v.begin(),
               v.end(),
               [](const std::string & e) {std::cout << e << std::endl;});
  return 0;

}

Bien sûr, cet exemple n'est pas vraiment moins verbeux qu'un BOOST_FOREACH ou que le nouveau ranged based for. Par contre, je m'attends à ce que cette fonctionnalité rende un std::accumulate beaucoup plus utile. Dans tous les cas, il sera agréable de ne pas à avoir à écrire de grosses boucles avec des itérateurs dans tous les sens.

Une autre fonctionnalité sympa pour la route, les variadic templates. Sans plus attendre, voyons un exemple:

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

void printElements()
{
}

template<typename T, typename... Args>
void printElements(const T & value, const Args&... args)
{
 std::cout << value << std::endl;
 printElements(args...);
}

int main()
{
 printElements(std::string("abc"), 17, 25.14, std::string("def"));
 return 0;
}

Le résultat est le suivant:

abc
17
25.14
def

Cet exemple créé une fonction qui peut recevoir n'importe quel nombre de paramètres de n'importe quel type, et les imprime. Elle fonctionne récursivement: le args... dans printElements sépare le premier argument des autres, et l'appel résout donc vers la même fonction template, avec une liste d'arguments variadiques réduite de 1. La récursion finit lorsque la liste d'arguments variadiques est vide, cas pour lequel c'est la fonction sans paramètres qui est appelée.

Je me demande si les templates variadiques pourraient résoudre mes problèmes de verbosité du code de base de données: pour le moment, je me retrouve à écrire une classe spécifique pour chaque appel, parce que les types d'entrée et de sortie sont particuliers à chaque classe. Avec les templates variadiques, il devrait être possible d'écrire quelque chose de générique... A creuser!