Discussion :

[Feriaman]

Bonjour, et merci de lire ce post.

Voici mon problème : j'ai un conteneur orienté de pointeurs d'objets de classe A, quelque chose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::list<A*> list;

la classe A peut être définie comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class A
{
public : 
   A();
   ~A();
   std::string& getText();
}

Et je voudrais concaténer ce que me renvoient les fonctions getText() des objets contenus dans la liste.

Autrement dit, ce que je voudrais faire c'est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
std::ostringstream oss;
for(std::list<A*>::iterator it = list.begin(); it != list.end(); it++)
{
   oss << it->getText();
}

Maintenant, je me demandais deux choses :
1 - s'il n'existait pas un moyen de faire la même chose en utilisant mem_fun, un ostream_iterator et std::copy ?
2 - si une telle méthode existait, serait-elle plus rapide que celle-ci ?

Merci de votre aide

[Laurent Gomila]

1- Ca risque d'être un peu compliqué avec la STL ; avec boost je pense que ce serait déjà un peu plus simple.

2- Absolument pas, la seule différence est que tu auras une écriture plus concise (enfin ça peut aussi être le contraire, à trop vouloir utiliser la STL on a tendance à faire n'importe quoi). Tout ce que font les diverses structures et fonctions de ce genre dans la STL, c'est cacher les boucles ou les opérateurs << que tu aurais écrit toi-même.

[Feriaman]

Merci beaucoup pour cette réponse.

Tant pis pour moi, j'aurais bien voulu apprendre quelque chose.

Hélas je ne peux pas utiliser boost dans ce projet-ci, ça m'aurait permis de m'y plonger un peu plus.

J'ai finalement opté pour un std::for_each et un foncteur hand-made que j'ai localisé dans mon objet A.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class A
{
public : 
   A();
   ~A();
public :
   std::string& getText();
public :
   class TextSerializer
  {
    ...
  };
};

Il me semble que c'est une bonne chose de faire un Foncteur, car je serais amené à utiliser plusieurs fois cette concaténation depuis divers endroits.

Il me semble que c'est une bonne chose de localiser ce bout de code dans ma classe A, car cela me permettra de le modifier simplement si je venais à changer ma fonction A::getText();

Qu'en pensez-vous ?

Merci de vos réponses.

Bonne journée.

[Alp]

Le laisser là est une idée correcte si uniquement la classe A se sert de TextSerializer.

Sinon, fais en un foncteur ou une fonction libre (du genre std::for_each, std::transform, ...).

Tu es dans lequel de ces cas ?

[Feriaman]

Le laisser là est une idée correcte si uniquement la classe A se sert de TextSerializer.

Sinon, fais en un foncteur ou une fonction libre (du genre std::for_each, std::transform, ...).

Tu es dans lequel de ces cas ?

Merci de cette réponse.

Il se trouve que pour sérializer A, il faut faire appel à la fonction getText(), il m'est donc impossible d'utiliser le TextSerializer sur un autre type d'objet.

Après, je pourrais aussi faire dépendre ma classe TextSerializer d'un pointeur fonction membre, auquel cas je pourrais effectivement le rendre indépendant.

Ou alors je pourrais faire une classe Serializable dont dériverait ma classe A, et à ce moment là TextSerializer dépendrait directement de Serializable.

Aucun de ces deux cas ne convient à mon application.

[yan]

Merci beaucoup pour cette réponse.

Tant pis pour moi, j'aurais bien voulu apprendre quelque chose.

Bonjour,
tu pourrai utiliser accumulate

Code C++ :

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 <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <numeric>
 
 
class A
{
public : 
	A(std::string s):m_s(s){};
	~A(){};
	const std::string& getText()const {return m_s;};
private:
	std::string m_s;
};
std::string concat(const std::string & s,const A * a) {return s+a->getText();};
 
int main(int argc, char** argv)
{
	std::vector<A*> vecttest;
	vecttest.push_back(new A("test1"));
	vecttest.push_back(new A("test2"));
	vecttest.push_back(new A("test3"));
	std::string s = std::accumulate(vecttest.begin(),vecttest.end(),std::string(""),&concat);
std::cout<<s<<std::endl;
return 0;
}

[Feriaman]

Bonjour,
tu pourrai utiliser accumulate

Class, je regarde de suite.

[yan]

Class, je regarde de suite.

Par contre, pour les perfs je ne garantie rien.