std erase : problême d'utilisation de pointeurs

Comment utiliser les fonctions std avec un std::vector<double**>

Sujet résolu

11 juillet 2007 à 13:39:58

Bonjour.

Tout est dans le sous-titre...
Je cherche à créer via la std un vector de pointeurs (je ne sais pas trop si ce sont les bonnes dénominations :euh:

).
Ce que je déclare comme ça :

std::vector<double**> maillageX;

Jusque là, tout roule.

Puis, je tente de l'utiliser. Pour ça :
1/ j'essaie maillageX.push_back(ax) (où ax est un double**) -> pas de problèmes
2/ J'essaie :

maillageX.insert(i,a1x); //ligne 875, i étant bien sûr déclaré et initialisé
maillageX.erase(i+1); //ligne 876

Et j'obtient :

1_quad_adaptatif.cpp: Dans function « int main() »:
1_quad_adaptatif.cpp:875: error: no matching function for call to `
   std::vector<double**, std::allocator<double**> >::insert(int&, double*[(d +
   1)])'
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/vector.tcc:89: error: candidates
   are: __gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc> >
   std::vector<_Tp, _Alloc>::insert(__gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >, const _Tp&;) [with _Tp = double**, _Alloc =
   std::allocator<double**>]
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/stl_vector.h:671: error:
                  void std::vector<_Tp,
   _Alloc>::insert(__gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc>
   >, unsigned int, const _Tp&;) [with _Tp = double**, _Alloc =
   std::allocator<double**>]
1_quad_adaptatif.cpp:876: error: no matching function for call to `
   std::vector<double**, std::allocator<double**> >::erase(int)'
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/vector.tcc:105: error: candidates
   are: __gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc> >
   std::vector<_Tp, _Alloc>::erase(__gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >) [with _Tp = double**, _Alloc =
   std::allocator<double**>]
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/vector.tcc:117: error:
                  __gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc> >
   std::vector<_Tp, _Alloc>::erase(__gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >, __gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >) [with _Tp = double**, _Alloc =
   std::allocator<double**>]

Pourquoi celà ne marche pas ?
Quelle est la différence entre push_back et insert ou erase ?

Merci d'avance

Anonyme

11 juillet 2007 à 13:57:01

Es-tu sûr que i est un iterator ?

Les erreurs de compilation en utilisant la STL sont souvent impressionnantes, mais il faut savoir dénicher ce qu'on cherche:

no matching function for call to `
std::vector<double**, std::allocator<double**> >::insert(int&, double*[(d +
1)])'

En bref, il n'a pas trouvé la fonction std::vector::insert(int&, double**), vu que insert fonctionne avec un iterator, pas avec un int. Les lignes d'après sont là pour te donner les prototypes de std::vector::insert existants.

La prochaine vraie erreur est:

error: no matching function for call to `
std::vector<double**, std::allocator<double**> >::erase(int)'

La aussi, il ne trouve pas la fonction std::vector::erase(int), à nouveau erase fonctionne avec un iterator. De même les lignes d'après sont les différents prototypes de std::vector::erase.

chenzy

11 juillet 2007 à 15:40:34

Arf, en effet, i est un int tout ce qu'il y a de plus banal :-°

Bon, j'ai remplacé ça par un iterator :

std::vector<double**> maillageX;
vector<int>::iterator iterX; //testé aussi avec std::vector<int>::iterator iterX;

maillageX.push_back(ax);
iterX=maillageX.begin(); //ligne 793

maillageX.insert(iterX,a1x); //ligne 881
maillageX.erase(iterX+1); //ligne 882

Ce qui donne :

1_quad_adaptatif.cpp:793: error: no match for 'operator=' in 'iterX =
   std::vector<_Tp, _Alloc>::begin() [with _Tp = double**, _Alloc =
   std::allocator<double**>]()'
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/stl_iterator.h:580: error: candidates
   are: __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>
   > >& __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>
   > >::operator=(const __gnu_cxx::__normal_iterator<int*, std::vector<int,
   std::allocator<int> > >&;)

1_quad_adaptatif.cpp:881: error: no matching function for call to `
   std::vector<double**, std::allocator<double**> >::insert(
   __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> >
   >&, double*[(d + 1)])'
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/vector.tcc:89: error: candidates
   are: __gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc> >
   std::vector<_Tp, _Alloc>::insert(__gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >, const _Tp&;) [with _Tp = double**, _Alloc =
   std::allocator<double**>]
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/stl_vector.h:671: error:
                  void std::vector<_Tp,
   _Alloc>::insert(__gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc>
   >, unsigned int, const _Tp&;) [with _Tp = double**, _Alloc =
   std::allocator<double**>]

1_quad_adaptatif.cpp:882: error: no matching function for call to `
   std::vector<double**, std::allocator<double**> >::erase(
   __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >)
   '
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/vector.tcc:105: error: candidates
   are: __gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc> >
   std::vector<_Tp, _Alloc>::erase(__gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >) [with _Tp = double**, _Alloc =
   std::allocator<double**>]
/usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include/g++-v3/bits/vector.tcc:117: error:
                  __gnu_cxx::__normal_iterator<_Tp*, std::vector<_Tp, _Alloc> >
   std::vector<_Tp, _Alloc>::erase(__gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >, __gnu_cxx::__normal_iterator<_Tp*,
   std::vector<_Tp, _Alloc> >) [with _Tp = double**, _Alloc =
   std::allocator<double**>]

La honte, même pas fichu d'initialiser correctement un iterateur ... Pourtant ça correspond aux rares déclarations que j'ai pu trouver sur le net -_-'

Au passage, si je veuxfaire des opérations sur un maillageX et un maillageY, je suis obligé d'utiliser deux iterator différents, ou un seul peut suffire ?

Merci.

PS : Dans ta signature, tu dois vouloir dire que tu est absent du 29/07 au 12/08
PPS : Bonnes vacances, même si j'espère que tu auras le temps de me répondre avant.

Anonyme

11 juillet 2007 à 15:45:46

Tu utilises un std::vector<double**>, donc ton itérateur doit être du type std::vector<double**>::iterator tout simplement.

Si tes deux maillages sont du même type (std::vector<double**>) un seul iterator peut suffire.

Pour ma signature, effectivement, merci :-°

.

EDIT: merci pour ton PPS, comme tu le vois j'ai pu te répondre

chenzy

11 juillet 2007 à 15:48:43

Ouéééé !!
Hum.
Merci.

lmghs

12 juillet 2007 à 1:11:49

Tous les algos sur les conteneurs standard sont orientés itérateurs et non indices...

Par contre, ce pointeur de pointeur dans un vecteur, cela me choque. Tu es sensé stocker quoi ? Des matrices ? -> utilises un type matrice plutôt!

chenzy

12 juillet 2007 à 11:47:01

Oui, je suis censé utiliser un tableau de matrices, sans savoir combien... D'où le double** pour les matrices (je commence a maîtriser plus ou moins les pointeurs), et le stl pour le tableau de dimention aléatoire.

Qu'est-ce le type matrice ? Parce qu'effectivement, pouvoir avoir autre chose comme déclaration serait pratique. Notemment pour stocker des matrices de tailles elles aussi inconnues.

Au passage, faire des matrices de vecteurs de tailles aléatoires, c'est possible aussi ? Parce que pour le coup, la technique "pointeurs+stl" n'y arrive pas.

lmghs

12 juillet 2007 à 22:17:18

A toi de l'écrire ou d'utiliser une des bibliothèques dédiées à cela.
Cela sera toujours 100 fois mieux que de mettre des pointeurs de pointeurs dans un vecteur, sans même associer les tailles.

Nanoc

13 juillet 2007 à 7:52:00

Il y a aussi la possibilité de voir une matrice comme étant:

std::vector< std::vector < double > > maMatrice;

ce qui permet de faire des matrices de n'importe quelle taille. (Elles auront cependant le défaut de pouvoir avoir des lignes de longueurs différentes.)

Et ta liste de Matrice sera alors:

std::vector< std::vector < std::vector< double > > > maMatrice; //ne pas oublier les espaces entre les > >

Le tout sera évidemment plus clair e utilisant un typedef:

typedef std::vector< std::vector < double > > Matrice;

std::vector < Matrice > maListe;

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

chenzy

13 juillet 2007 à 9:13:47

Je suis justement en train de tenter ça pour un tableau 3D, mais j'ai d'autre problèmes avec ... Enfin bref.

Et justement, cette déclaration fait que non seulement chaques lignes/colonne peut être de taille différente, mais en plus, on ne connaît pas à l'avance leur taille, ce qui est le cas de mes pointeurs (même si la taille n'est pas déclarée dans l'appel du vector<double**>, dans les fait, quand je l'utilise, j'y rajoute toujours des poiteurs de même taille). Ce qui permet de ne pas avoir de push_back à faire en permanence, de gérer plus facilement les indices, tout ça. Enfin, ce n'est qu'une question d'habitude je suppose.

Nanoc

13 juillet 2007 à 9:26:47

Si ça te dérange, il est toujours possibles d'utiliser d'autres conteneurs que les std::vector

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

lmghs

13 juillet 2007 à 9:46:11

maths: boost.ublas, blitz++, MTL, newmat, ...
autre: boost::multi_array, stl_soft::array2d, 3d, ...