Discussion :

[bobyjoe]

Voici un code qui initialise un conteneur set avec un type class. Le but est de parcourir les éléments du conteneur et d'appeller une fonction membre de la classe à partir de l'iterateur.

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
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <set>
 
class ict{
	public:
 
		void print()
		{
			printf("%d\n",a);
		}
		void set(int _a)
		{
			a = _a;
		}
	private:
	int a;
};
 
int main( int argc, char *argv[])
{
	std::set<ict> v;
 
	ict ia;
 
	/* Ajouter 3 objets instance de la classe ict
	 * avec des valeurs différentes */
	ia.set(1);
	v.insert(v.end(), ia);
 
	ia.set(2);
	v.insert(v.end(), ia);
 
	ia.set(3);
	v.insert(v.end(), ia);
 
	std::set<ict>::iterator iter;
 
	for(iter = v.begin(); iter != v.end(); iter++)
	{
		iter->print();
	}
 
	return 0;
}

Le compilateur n'aime pas ça du tout (G++):

set.cpp:35: erreur: passing «const ict» as «this» argument of «void ict::print()» discards qualifiers

PS: Bizarrement (je comprends pas pourquoi) ca fonctionne lorsqu'on utilise <vector>, et pas avec <set>.

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
31
32
33
34
35
36
37
#include <vector>
 
class ict{
	public:
 
		void print()
		{
			printf("%d\n",a);
		}
		void set(int _a)
		{
			a = _a;
		}
	private:
	int a;
};
 
int main( int argc, char *argv[])
{
	ict ia;
	std::vector<ict> v;
	ia.set(1);
	v.push_back(ia);
	ia.set(2);
	v.push_back(ia);
	ia.set(3);
	v.push_back(ia);
 
	std::vector<ict>::iterator iter;
 
	for(iter = v.begin(); iter != v.end(); iter++)
	{
		iter->print();
	}
 
	return 0;
}

C'est pourtant la même manière d'accéder à la fonction membre à partir de l'itérateur.

[Laurent Gomila]

Parce que set::iterator est en fait un set::const_iterator (on ne doit pas pouvoir modifier les éléments : cela casserait l'ordre). Donc tu ne peux appeler que des fonctions constantes des objets du set. Si tu dois vraiment modifier un élement, il faut le retirer et le réinsérer.

[bobyjoe]

Mouais, je vais pas dire que ca me réjouit.

C'est clair, mais ca m'arrange pas disons.

Surtout que je ne veux pas forcément modifier le contenu.

Autre exemple, voici un code qui fonctionne en utilisant des <int> comme type de contenu.
Source: http://www.cplusplus.com/reference/stl/set/find.html

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
// set::find
#include <iostream>
#include <set>
using namespace std;
 
int main ()
{
  set<int> myset;
  set<int>::iterator it;
 
  // set some initial values:
  for (int i=1; i<=5; i++) myset.insert(i*10);    // set: 10 20 30 40 50
 
  it=myset.find(20);
  myset.erase (it);
  myset.erase (myset.find(40));
 
  cout << "myset contains:";
  for (it=myset.begin(); it!=myset.end(); it++)
    cout << " " << *it;
  cout << endl;
 
  return 0;
}

Maintenant modifions le pour utiliser des objets instance d'une classe aulieu des <int>.

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
// set::find
#include <iostream>
#include <set>
using namespace std;
 
class myint
{
	public:
		void set(int a)
		{
			_a = a;
		}
		int val()
		{
			return(_a);
		}
	private:
		int _a;
};
 
int main ()
{
  set<myint> myset;
  set<myint>::iterator it;
 
  myint object;
  // set some initial values:
  for (int i=1; i<=5; i++)
  {
	  object.set(i*10);
	  myset.insert(object);    // set: 10 20 30 40 50
  }
 
  object.set(20);
  it=myset.find(object);
  myset.erase (it);
  object.set(40);
  myset.erase (myset.find(object));
 
  cout << "myset contains:";
  for (it=myset.begin(); it!=myset.end(); it++)
    cout << " " << it->val();
  cout << endl;
 
  return 0;
}

Je ne modifie en rien le contenu. Je ne fais que d'appeller une fonction qui renvoit la valeur.

Pire, si j'appelle une fonction membre print(), ca revient au même. Le compilateur gueule.

moresetclass.cpp:42: erreur: passing «const myint» as «this» argument of «int myint::val()» discards qualifiers

Et toujours au même endroit "it->val()".

Cette écriture selon lui, perd des informations.

[Laurent Gomila]

C'est juste que tu ne rends aucune fonction constante, alors qu'elles devraient l'être.

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
class myint
{
	public:
		void set(int a)
		{
			_a = a;
		}
		int val() const
		{
			return(_a);
		}
		void print() const
		{
			std::cout << _a;
		}
 
	private:
		int _a;
};

[bobyjoe]

mhh je crois qu'on a un gagnant !

Je vais tester ca plus en profondeur, mais le message d'erreur n'appraît déjà plus, c'est plutôt bon signe. J'ai encore d'autres erreurs mais c'est assez compliqué à expliquer.

En tout cas merci, j'ai eu exactement ce que je voulais.