Discussion :

[ToTo13]

Bonjour,

j'ai une classe qui utilise des templates :

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
 
template <typename T, int dim, typename T2> class myclass
{
public:
	T1 Coordinates[dim] ;
	T2 Weight ;
 
myclass()
	{
	}
 
myclass(T1 x, T1 y)
	{
	//...
	}
 
myclass(T1 x, T1 y, T2 w)
	{
	//...
	}
}

Maintenant, je souhaiterai créer un tableau de type myclass, mais chaque entrée sera initialisée avec des éléments différents provenant d'autres tableau... donc quelque chose du genre :

Code c++ :

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

1
2
3
4
5
6
7
8
 
#define length 10
int X[length] ;
int Y[length] ;
double W[length] ;
//... Les tableaux sont remplis de manière aléatoire ou par lecture d'un fichier ...
myclass<int, 3, double> array[length] ;
for (int i=0 ; i < length ; i++) array[i] = new Point(X[i], Y[i], W[i]) ;

Mais si je fais un truc de ce style, je pense que je vais instancier deux fois chaque élément du tableau. Est ce que j'ai tord ?
Quelle est la bonne façon de faire ?
Merci par avance !

[prgasp77]

std::vector + std::vector:reserve + std::vector::emplace_back ?

Code :

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

1
2
3
4
5
6
std::vector<myclass<int, 3, double> > myobjects;
myobjects.reserve(length);
for (int i=0 ; i < length ; i++)
{
    myobjects.emplace_back(X[i], Y[i], W[i]);
}

[ToTo13]

Merci pour la réponse !

[ToTo13]

J'ai une question à propos de la désallocation dans ce cas précis. Comme le tableau "T1 Coordinates[Dimensions]" est static, il sera automatiquement libéré lorsque l'instance de myclass n'existera plus. Donc je n'ai pas besoin de faire quoi que ce soit pour la désallocation de ce vector : le destructor du vector va tenter de désallouer chaque instance (qui ne contiennent que du static).
Donc rien à faire dans mon cas. Est ce bien cela ?

Par pure curiosité : qu'elle est la solution en n'utilisant que des tableaux et pas des vector ?

[jo_link_noir]

J'ai une question à propos de la désallocation [...] Donc rien à faire dans mon cas. Est ce bien cela ?

Oui

Par pure curiosité : qu'elle est la solution en n'utilisant que des tableaux et pas des vector ?

Code :

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

1
2
3
auto array = std::apply/*¹*/([](auto&... x) {
  return std::array<myclass<int, 3, double>, sizeof...(x)>{{x, Y[x-X], Z[x-X]}...};
}, /*tuple_view(*/X/*)*/);

Les autres solutions sont trop compliquées .

En réalité, soit tu fais à la main l'initialisation (sans boucle), soit tu déclares un tableau (appel de constructeur par défaut) puis affecte une nouvelle valeur avec une boucle.

L'utilisation de vector possède aussi un coup et le compilateur ne sera peut-être pas capable d'optimiser emplace_back.
Le constructeur avec itérateurs est plutôt bon quand le compilateur optimise l'appel au constructeur de copie (quasi obligé avec les itérateur...), mais l'écriture du dit itérateur est une vrai plaie.
La forme optimal pour vecteur serait un constructeur qui appel n fois une callback avec une façade qui servirait de constructeur pour initialiser la mémoire sans copie (oui, c'est incompréhensible).

Pour avoir une boucle qui construit un tableau statique de façon optimale, il faudrait le faire à la main et en 2 étapes: un buffer mémoire et une vue sur le buffer qui fait du placement new dans le constructeur et imite l'interface d'un tableau.

Personne ne veut faire cela ². En plus, le code ne me semble pas critique, inutile de se prendre la tête.


¹ http://en.cppreference.com/w/cpp/experimental/apply Mais il faut faire une implémentation de get<I> pour les tableaux c-style ou passer par une vue intermédiaire. Quant-on dit t'utiliser std::array...
² TODO: le faire

[ToTo13]

merci !
Mais la solution simple est quand même un peu tordue ;-)