Discussion :

[Mikkkka]

Bonjour � tous,

Alors pour la petite histoire, j'ai touch� � pas mal de langages informatiques. A la base j'�tais un peu du genre pro-java et le C++ me faisait pousser des boutons, mais je pense que la fac nous am�ne un peu � penser ce genre de choses... Enfin bref, dans un soucis de performances (ex�cution et m�moire) je suis pass� au C++ il y a un peu plus de 3 ans. � la base s'�tait surtout pour faire un petit test de performance et je dois dire que je suis franchement rest� sur le cul, surtout pour la m�moire o� j'ai vu la consommation fondre comme neige au soleil.

Le C++ r�ponds � mes attentes � ce niveau l� et en bonus j'ai de plus �t� extr�mement s�duit par la puissance des templates et les nouveaut�s du C++11. Sauf que depuis le d�but j'ai beaucoup de mal avec la biblioth�que standard. Non pas que je n'arrive pas � m'en servir ou que je ne la comprenne pas, mais je la trouve assez lourde � utiliser. Je pense clairement tout d'un point de vue orient� objet, design pattern, etc... et ce qui est propos� par la biblioth�que stantard ou boost ne me satisfait pas compl�tement. J'aime l'approche orient� objet mais aussi l'approche langage "fonctionnel" qu'apportent les lambdas avec C++11.

Du coup je me suis d�velopp� une petite biblioth�que durant mon temps libre. Le but est le suivant: gr�ce au C++11 simplifier un maximum ce que parfois la biblioth�que standard ou bien l'association avec boost prends plusieurs lignes � �crire, tout en gardant un code clair et parlant. Pour pr�senter rapidement l'approche (car la biblioth�que commence � devenir assez grosse, avec de nombreux concepts que je ne vais pas pr�senter ici), je vais prendre un exemple simple o� l'on souhaite manipuler un fichier texte et � r�cup�rer toutes les lignes qui contiennent des mots qui commencent par "bb", et pour finir afficher les lignes s�lectionn�es.

En C++ classique :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
std::ifstream file("MonFichier.txt"); 
 
std::vector<std::string> interesting_lines;
 
if(file) {
    std::string line;
    boost::char_separator<char> separator(";");
 
    while(std::getline(file, line)) {
        boost::tokenizer<boost::char_separator<char> > token(line,separator);
        boost::tokenizer<boost::char_separator<char> >::iterator word_iterator=token.begin();
 
        while(word_iterator!=token.end()) {
            if(boost::starts_with( *word_iterator, "bb")) {
                interesting_lines.push_back(line);
                break;
            }
            ++word_iterator;
        }
    }
 
    file.close();
}
else
    throw std::logic_error( "Impossible d'ouvrir le fichier" );
 
for(std::string line : interesting_lines) {
    std::cout << line << std::endl;
}

Avec ma biblioth�que :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
oo::File file("monFichier.txt")
 
oo::Vector<oo::String> interesting_lines;
 
interesting_lines = file.collect_if([] (oo::String& line) {
 
    return line.split(";").is_any([] (oo::String& word) {
 
        return word.start_with("bb");
    });
});
 
interesting_lines.each([](oo::String& line) {
    std::cout << line << std::endl;
});

Si certains connaissent Ruby, vous y aurez s�rement reconnu une claire influence, j'use et j'abuse des lambdas. Bref, c'est en fin de compte tr�s proche de ce que l'on peut faire avec un std::copy_if ou bien un std::any_of, mais il n'y a pas la gestion des pointeurs de d�but et de fin (que je trouve p�nible � �crire et � lire). En surchargeant les lambdas, je peux �galement faire :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
oo::File file("monFichier.txt")
 
oo::Vector<oo::String> interesting_lines;
 
interesting_lines = file.collect_if([] (oo::Sentence& sentence) {
 
    return sentence.split(";").is_any([] (oo::String& word) {
 
        return word.start_with("bb");
    });
});
 
interesting_lines.each([](oo::String& line) {
    std::cout << line << std::endl;
});

Ici nous ne prenons plus le probl�me ligne par ligne, mais phrase par phrase (donc s�par� par un point). En fait j'utilise ce syst�me car il s'av�re extr�mement flexible. Dans ce cas ci, j'ai deux classes abstraites IterableElement et CollectableElement qui impl�mentent les fonctions is_any() et collect_if() respectivement. Ces deux classes d�finissent une m�thode abstraite each() utilis�e par is_any() et collect_if() et qui doit �tre impl�ment�e dans la classe fille, et qui permet d'it�rer sur des �l�ments d'un type T (ici String et Sentence). Pour info, je pr�cise que IterableElement et CollectableElement poss�dent bien plus de fonctions, mais j'ai simplifi�.
-> Toute classe qui h�rite de IterableElement<T> et CollectableElement<T> et qui impl�mente la fonction each() pour l'�l�ment T pourra utiliser les lambas impl�ment�es dans les classes m�res
-> Du coup il est possible d'h�riter plusieurs fois d'une de ces classes avec un type diff�rent pour multiplier les possibilit�s.

Pour un exemple peut �tre plus concret, prenons un multigraphe (plusieurs ar�tes possibles entre deux sommets) non dirig� qui peut avoir des ar�tes color�s et des sommets color�s. Le probl�me est de supprimer tous les sommets bleus qui ont toutes leurs ar�tes connect�es qui sont rouges :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
 
oo::MultiGraph<oo::Color, oo::Color> g = fonctionQuiGenereMonGraphe();
 
g.remove_if([] (oo::MultiGraph::Vertex<oo::Color, oo::Color> vertex) {
 
    return (vertex.label() == oo::Color::Blue) 
        && vertex.is_all([] (oo::MultiGraph::Edge<oo::Color, oo::Color> edge) {
 
            return edge.label() == oo::Color::Red;
        });
});

Inversement si l'on souhaite supprimer toutes les ar�tes rouges qui ont tous leurs sommets connect�s qui sont bleus :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
 
oo::MultiGraph<oo::Color, oo::Color> g = fonctionQuiGenereMonGraphe();
 
g.remove_if([] (oo::MultiGraph::Edge<oo::Color, oo::Color> edge) {
 
    return (edge.label() == oo::Color::Red) 
        && edge.is_all([] (oo::MultiGraph::Vertex<oo::Color, oo::Color> vertex) {
 
            return vertex.label() == oo::Color::Blue;
        });
});

J'ai mes propres versions des containers de la biblioth�que standard : Vector, Set, List, Map que j'ai seulement encapsul� et enrichi des nouvelles m�thodes. Puis j'ai d'autres structures de donn�es plus complexes : Sequence, Graphe, MultiGraph, DirectedGraph, DirectedMultiGraph, Matrix, MapMatrix. Au niveau perf il faudrait que je fasse des benchmarks mais honn�tement je n'ai pas not� de grosses diff�rences � utiliser les lambdas. De plus lorsque l'on voit un objet oo::MultiGraph::Edge pour un graphe, on peut se dire que derri�re il y a beaucoup d'objets. En fait non, derri�re j'ai par exemple simplement une matrice d'adjacence et les objets sont simplement g�n�r�s � la vol�e pour la lambda et cela reste transparent pour l'utilisateur.

Ma question est que pensez vous d'un tel design ? Y voyez vous des inconv�nients ou bien avez vous des remarques ?

Je pr�cise que j'ai appris le C++ tout seul, ne me maltraitez pas trop svp.

[Trademark]

Salut,

Ta biblioth�que semble te convenir et c'est tr�s bien :-) N�anmoins elle n'est pas du tout dans l'esprit C++, quand la STL a �t� cr��e l'id�e g�n�rale �tait d'avoir d'un c�t� les structures de donn�es et d'un autre les algorithmes, dans ta biblioth�que tu mixes les deux. N�anmoins le cha�nage peut s'av�rer tr�s int�ressant et plus clair � lire comme tu le d�montres mais dans ce cas j'aurais plut�t fait des wrappers g�n�riques qui permettent le cha�nage comme :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
std::ifstream file("monFichier.txt");
std::vector<std::string> interesting_lines;
oo::stream_algo_wrapper<std::ifstream> file_wrapper(file);
 
interesting_lines = file_wrapper.collect_if([] (const std::string& line) {
    return line.split(";").is_any([] (const std::string& word) {
        return word.start_with("bb");
    });
});

L� je serais plus int�ress� vu que j'utiliserais toujours les containers standards et qu'il me suffit de les wrapper (j'entend que le wrapper contienne une r�f�rence � l'objet) pour faire du cha�nage.

� part �a, il va sans dire que "designer" une biblioth�que est tr�s difficile car il faut rester g�n�rique ce que ne fait pas ta biblioth�que (exemple : wchar_t ?), tu r�sous le cas g�n�rale, ou plut�t ton cas g�n�ral, ce qui en fait une biblioth�que puissante pour toi mais pas forc�ment pour les autres. Ce n'est pas mal mais il faut s'en rendre compte :-)

As-tu un d�p�t github ou autre pour qu'on voit plus en d�tail le reste ?

[Mikkkka]

Salut,

Merci pour ton retour Trademark, je trouve ta remarque tr�s int�ressante !

Mes classes comme File ou Vector encapsulent en fait leur �quivalent C++ mais je n'avais pas du tout pens� au wrapper et j'aime beaucoup cette id�e. Du coup je me dis que cela pourrait �tre envisageable sans trop de changements pour avoir une r�f�rence encapsul�e plut�t qu'une variable classique, tout du moins pour les types qui ont leur �quivalent en C++. Id�e a creuser.

Tu peux m'en dire plus sur wchar_t (je ne connais pas) et sur les probl�mes que cela soul�ve ?

Non je n'ai pas de github, c'�tait justement en perspectives au cas o� mon approche pouvait int�resser quelqu'un.

[Trademark]

wchar_t c'est juste pour stocker des caract�res sur deux bytes (UTF-8 si c'est max 2 bytes ou UTF16), et il y a plein de d�tail du genre comme la localisation, etc. qui font que ta lib ne sera pas g�n�rique, �a prend des mois voir des ann�es avant d'avoir une vraie biblioth�que.

[Mikkkka]

Bien entendu mon but de base n'est pas de rivaliser avec ce qui se fait de mieux dans boost ou bien la librairie standard. J'imagine bien qu'avoir une g�n�ricit� parfaite est difficile surtout avec un langage riche comme C++, et ce n'est pas mon objectif.

Comme tu l'as dit c'est g�n�rique dans mon cas et j'ai surtout fait cela pour me simplifier la t�che dans mes algos. En fait je travaille dans la recherche en fouille de donn�es, les algos peuvent devenir extr�mement complexes et les optimiser entra�ne un bordel monstre, un maximum de lisibilit� est primordial. Je d�veloppe dans mon temps libre pour m'aider dans le boulot on va dire, puis surtout pour le fun. Par exemple l� je pr�vois d'int�grer une notion de visualisation de mes structures de donn�es, �a peut m'�tre tr�s utile pour le debug. Si par exemple j'utilise un DirectedGraph qui s'av�re �tre un arbre, de pouvoir g�n�rer le javascript qui corresponds � �a http://mbostock.github.io/d3/talk/20111018/cluster.html, si j'ai une Matrix de g�n�rer quelque chose comme �a http://bost.ocks.org/mike/miserables/ et si je fais un clustering de g�n�rer un truc de ce genre http://bl.ocks.org/mbostock/1747543

M�me si cela ne corresponds pas aux principes du C++ et de la biblioth�que standard, mon objectif c'est d'essayer de me simplifier la tache concernant les probl�mes que je rencontre. Je me disais que cela pouvait peut �tre (modestement) servir � d'autres.

[Trademark]

En tout cas c'est pas une mauvaise id�e, je trouve aussi que le cha�nage peut parfois rendre les choses plus clairs. Je pense que �a pourrait d�j� �tre plus utile si tu utilises un syst�me de wrapper, je viens de penser � un truc :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
std::ifstream file("xxx");
prepare(file).filter(...).remove_if(...);

Le prepare (d�sol� pour le nom...) renvoit le wrapper sur le type pass� en param�tre. Apr�s je me demande si ce genre de chose n'a pas d�j� �t� faite, il faudrait se renseigner. En plus niveau perfs ces m�thodes peuvent renvoyer des vues (et donc ne pas calculer imm�diatement) et on pourrait tout calculer d'un coup � la fin.

[Iradrille]

je vais prendre un exemple simple o� l'on souhaite manipuler un fichier texte et � r�cup�rer toutes les lignes qui contiennent des mots qui commencent par "bb", et pour finir afficher les lignes s�lectionn�es.

En "C++ classique", il y � plus simple (overkill les regex pour �a ? :p)

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
std::ifstream f("file.txt");
if(!f) {
	throw std::logic_error("Impossible d'ouvrir le fichier");
}
std::string str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
 
std::smatch m;
std::regex e(".*bb.*\\n");
 
while(std::regex_search(str, m, e)) {
	std::cout << *m.begin(); // la ligne contient déja '\n'
	str = m.suffix().str();
};

Mais sinon, m�me si le cha�nage est des-fois plus lisible, �a reste dur � maintenir, il risque d'y avoir un �norme arbre d'h�ritage soit directement au niveau des conteneurs, soit au niveau des wrappers.
C'est la principale motivation pour les fonctions libres

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
conteneur.any_of(...);
// vs
std::any(conteneur);

Dans le cas d'une fonction libre, c'est seulement une surcharge / sp�cialisation � fournir.

Par contre la STL devrait fournir des helpers pour agir sur un conteneur complet, du type

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
std::vector<int> vi;
std::find(vi, 42);
// qui serait équivalent à 
std::find(vi.begin(), vi.end(), 42);

C'est peut �tre existant dans boost, je sais pas.

[white_tentacle]

Par contre la STL devrait fournir des helpers pour agir sur un conteneur complet, du type

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
std::vector<int> vi;
std::find(vi, 42);
// qui serait équivalent à 
std::find(vi.begin(), vi.end(), 42);

C'est peut �tre existant dans boost, je sais pas.

Je crois que c�est Alexandrescu qui a bien r�sum� le probl�me en disant que les it�rateurs, c�est de la merde et qu�on devrait utiliser des � range � � la place. Les range ayant une garantie tr�s forte par rapport aux it�rateurs, qui est que le first et le last appartiennent au m�me conteneur.

Du coup, c�est impl�ment� dans D si je ne plante pas. Jamais eu l�occasion de l�utiliser en revanche, donc je ne sais pas si c�est vraiment un gain au final ou pas.

[Iradrille]

Du coup, c�est impl�ment� dans D si je ne plante pas. Jamais eu l�occasion de l�utiliser en revanche, donc je ne sais pas si c�est vraiment un gain au final ou pas.

Et c'est en partie ce qui permet � une fonction prenant un tableau (ou simplement un range ?) en premier argument d'�tre utilis�e de 2 fa�ons

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
fonction(tableau, ...);
tableau.fonction(...);

(Ce qui, au passage, r�pond directement au probl�me dont on parle : le cha�nage d'appel est possible, sans payer le prix de la maintenabilit�)

[CedricMocquillon]

Avec boost, on peut faire quelque chose de tr�s proche de ce que tu proposes avec ta lib (sur le premier exemple):

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <string>
 
#include <boost/tokenizer.hpp>
#include <boost/range/istream_range.hpp>		//istream_range
#include <boost/range/adaptor/filtered.hpp>		//filtered
#include <boost/range/adaptor/tokenized.hpp>	//tokenized
#include <boost/range/algorithm/for_each.hpp>	//for_each
#include <boost/algorithm/string/predicate.hpp>	//start_with
#include <boost/algorithm/cxx11/any_of.hpp>
 
int main()
{
  using namespace boost;
  using namespace adaptors;
  using namespace algorithm;
 
  typedef char_separator<char> separator_t;
  typedef tokenizer<separator_t> tokenizer;
  auto interesting_lines = istream_range<std::string>(std::cin) | filtered([](std::string const& line) {
    return any_of(tokenizer(line, separator_t(";")), [](std::string const& word) {
      return starts_with(word, "bb");
    });
  });
 
  for_each(interesting_lines, [](std::string const& l) {
    std::cout << l << std::endl;
  });
}

Edit: th�oriquement y'a m�me moyen de faire un truc comme �a:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
  auto interesting_lines = istream_range<std::string>(std::cin) | filtered([](std::string const& line) {
    return any_of(line | tokenized(";"), [](std::string const& word) {
      return starts_with(word, "bb");
    });
  });
 
  for_each(interesting_lines, [](std::string const& l) {
    std::cout << l << std::endl;
  });

Mais j'avoue que chez moi �a ne fonctionne pas (tout les exemples � base de tokenized ne marchent pas...)

[Mikkkka]

En fait, sur ce point, c�est juste une question de qu�est-ce que tu fournis comme it�rateurs. Fondamentalement, ta classe matrice pourrait exposer des it�rateurs diff�rents pour it�rer selon les lignes, les colonnes, les cellules. Je ne vois pas trop en quoi le concept d�it�rateur est incompatible avec ce que tu d�cris. Que les it�rateurs des conteneurs standards ne conviennent pas, oui, mais que tu ne puisses pas utiliser d�it�rateurs, non, pas d�accord .

En effet, tr�s int�ressante ta remarque. En fait je m�aper�ois que je connais mal le fonctionnement interne des it�rateurs. Je vais regarder comment �a fonctionne, si c'est simple � impl�menter et voir ce que cela pourrait donner.

En fait vous m'avez tous donn� pleins d'id�es, je vais pr�parer un petit code avec un exemple minimal dans le weekend. Par contre cette fois ci je prendrai comme exemple les matrices et pas le chargement d'un fichier. En fait j'ai l'impression que beaucoup ont bloqu� la dessus alors qu'en fait � la base je cherchais juste un exemple tout b�te pour montrer ma m�thodologie, mais je sais qu'il y a d'autres approches/m�thodes plus adapt�es comme l'utilisation des expressions r�guli�res.

En gros l� je pars sur une structure de donn�es std::array<int, nombre_lignes*nombre_colonnes> pour repr�senter une matrice. Cette structure sera envoy�e dans un wrapper qui permettra de renvoyer des it�rateurs sur les diff�rentes vues de la matrice. Ces vues devront permettre d'explorer chaque lignes, chaque colonne, chaque diagonale et chaque cellule de la matrice. Les vues pourront elles m�mes renvoyer des it�rateurs vers d'autres vues. Par exemple � partir d'une vue ligne je dois pouvoir it�rer sur les vues cellules de la ligne, ou � bien l'inverse repartir vers les vues lignes, colonnes, diagonales � partir d'une vue cellule. �galement les vues pourront renvoyer des infos sur le fait concern�, comme les indices i,j d'une cellule (bon c'est d�j� le cas en fait).

Est-ce que �a vous semble pertinent une approche de ce type ?

Au pire m�me si cela donne une utilisation bizarre, j'aurai au moins appris � impl�menter des it�rateurs. Et je suis toujours preneur de ce genre de choses.

En fait je crois que si j'ai du mal avec l'utilisation des algos dans la librairie standard c'est que j'ai toujours �t� habitu� au "tout objet". Du coup utiliser une fonction externe � ma classe pour la modifier je n'y suis pas du tout habitu�, ce n'est pas naturel pour moi.

Oui . La move semantic et les unique_ptr, plus les lambdas �a change vraiment la vie. Dur de revenir en arri�re quand on doit bosser sur du code C++03 apr�s �a.

Oui c'est clair, avec le C++11 on a presque un tout nouveau langage.