Discussion :

[Gébix]

Bonjour,

J'ai deux méthodes très semblable :

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
	void replicateFrom(const std::list<T>& l) {
		reinit(l.size());
 
		int i = 0 ;
		for(typename std::list<T>::iterator it=l.begin(); it!=l.end();
			 ++it, ++i)
			data[i] = *it ;
	}
 
	void replicateFrom(const std::vector<T>& v) {
		reinit(v.size());
 
		int i = 0 ;
		for(typename std::vector<T>::iterator it=v.begin(); it!=v.end(); ++it, ++i)
			data[i] = *it ;
	}

Je me demandais s'il y avait une solution pour en faire qu'une seule. Quelqu'un aurait-il une idée à me suggérer ?

[dragonjoker59]

tu n'as qu'à passer les itérateurs et la taille en paramètre d'une fonction template qui fera le travail :

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
 
template <typename ItType>
void replicateFrom( ItType itBegin, ItType itEnd, size_t uiSize)
{
	reinit( uiSize);
 
	int i = 0 ;
	for(ItType it = itBegin ; it != itEnd ; ++it, ++i)
	{
		data[i] = * it;
	}
}
//utilisation :
replicateFrom<std::vector<T>::const_iterator>( myVector.begin(), myVector.end(), myVector.size());
replicateFrom<std::list<T>::const_iterator>( myList.begin(), myList.end(), myList.size());

[Gébix]

merci. Je pense que je vais garder ma première solution qui me demande moins de code lors de l'appel aux méthodes.

[Arzar]

Bonjour,
L'idée proposée par dragonjoker59 - passer un couple d'itérateur - est bonne. Par contre il n'utilise pas le fait que les arguments template d'une fonction peuvent être déduits lors de l'appel de la fonction. On peut écrire plus simplement :

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
template <typename ItType>
void replicateFrom( ItType itBegin, ItType itEnd)
{
   int uiSize = std::distance(itBegin, itEnd);
   reinit( uiSize);
 
   int i = 0 ;
   for(ItType it = itBegin ; it != itEnd ; ++it, ++i)
   {
      data[i] = * it;
   }
}
 
int main()
{
   std::vector<int> myVector;
   std::list<int> myList;
   replicateFrom( myVector.begin(), myVector.end());
   replicateFrom( myList.begin(), myList.end());
}

[r0d]

Sinon, j'ai une fonction de ma lib perso dont tu pourrais t'inspirer:

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
#include <iostream>
#include <vector>
 
using namespace std;
 
template <typename Container>
void PrintContainer( ostream & ostr, const Container & container )
{
	for ( Container::const_iterator it = container.begin(); it != container.end(); ++it )
		ostr << (*it) << " ";
	ostr << endl;
}
 
int main()
{
	vector< int > v_int;
	v_int.push_back( 3 );
	v_int.push_back( 6 );
	vector< float > v_float;
	v_float.push_back( 3.5f );
	v_float.push_back( 6.6f );
 
	PrintContainer( cout, v_int );
	PrintContainer( cout, v_float );
 
	cin.get();
	return 0;
}

output:

3 6
3.5 6.6

[cob59]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int data[TAILLE_DATA];
std::vector<int> myVector(TAILLE_DATA);
std::list<int> myList(TAILLE_DATA);
 
// Remplissage de myVector et myList
(...)
 
// Recopie de l'ensemble de myVector vers data
std::copy(myVector.begin(), myVector.end(), data);
 
// Recopie de l'ensemble de myList vers data
std::copy(myList.begin(), myList.end(), data);

Je crois que ça pourrait répondre plus largement à ton problème...