Discussion :

[LinuxUser]

Bonjour,

Admettons que l'on ait un tableau d'objets quelconque :

Code :

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

1
2
 
        maClasse tableau[5];

Je souhaiterai supprimer le iéme element de mon tableau, peut on copier un objet simplement en faisant : monObjetTampon = monObjet.
En fait ce que je pensais faire, c'est :

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
 
// soit n l'indice de l'element a supprimer, n etant recupere ailleurs
 
maClasse tableauTampon[4];
i=0;
j=0;
while(i<nombreObjets)
{
   if(i != n)
  {
    tableauTampon[j] = tableau[i];
    j++;
  }
   else
     printf(" L'element %d a ete supprime \n",n);
 
i++;
}
 
tableau = tableauTampon;

Est - ce possible;
Est-il suffisant de mettre "=" pour recopier un objet dans un autre voire un tableau d'objet dans un autre ou faut-il utiliser une methode pour cela;

Merci

[ZouBi]

non, tu dois utiliser des pointeurs et allocation dynamiques.

Voilà ce que ca donne chez moi

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
void ListeElements::supprimer(int pos)
{
	int i;
 
	Element** tmp_liste_elements = new Element*[m_nb_elements];
	for(int i=0; i < m_nb_elements; i++)
		if( i == pos )
		{
			delete m_liste_elements[i];
			tmp_liste_elements[i] = NULL;
		}
		else
		{
			tmp_liste_elements[i] = m_liste_elements[i];
		}
 
	m_nb_elements--;
	delete m_liste_elements;
	m_liste_elements = new Element*[m_nb_elements];
 
	i = 0;
	while(tmp_liste_elements[i] != NULL)
	{
        m_liste_elements[i] = tmp_liste_elements[i];
        i++;
	}
	while( i < m_nb_elements )
	{
        m_liste_elements[i] = tmp_liste_elements[i+1];
        i++;
	}
 
	delete tmp_liste_elements;
}

( et qu'on m'dise pas encore d'utiliser des vecteurs... )

et ne pas oublier à desallouer à la fin de ton programme

Code :

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

1
2
3
for(int i=0; i<m_nb_elements; i++)
		delete m_liste_elements[i];
	delete[] m_liste_elements;

[Sylvain Togni]

Si t'es masochiste, utilise la solution de ZouBi ;-)
Sinon utilise std::vector et sa fonction erase().

[LinuxUser]

Je ne connais pas std::vector ni la méthode erase(), pour l'utiliser il faut que mes objets héritent d'un classe en particuliere?
Je ne connais pas le C++, y a t-il une doc du style des API java pour que je puisse m'y retrouver?

[loufoque]

Ta solution aurait été parfaitement valide si tu n'avais pas utilisé les tableaux de C mais std::tr1::array.
En effet, les tableaux de C ne sont pas Assignable.

Ton code corrigé :

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
#include <iostream>
#include <tr1/array>
 
using std::tr1::array;
 
struct maClasse {};
 
int main()
{
	array<maClasse, 5> tableau;
	int nombreObjets = 4;
 
	array<maClasse, 5> tableauTampon;
	int i = 0;
	int j = 0;
 
	int n = 2;
	while(i < nombreObjets)
	{
		if(i != n)
		{
			tableauTampon[j] = tableau[i];
			j++;
		}
		else
			std::cout << "L'élément " << n << " a été supprimé" << std::endl;
 
		i++;
	}
	nombreObjets--;
 
	tableau = tableauTampon;
 
	return 0;
}

Cela reste assez stupide.
Mieux vaut faire un memmove(tableau+n, tableau+n+1, nombreObjets-n-1)

[koala01]

Salut,

Le C++ est un langage orienté objet, qui fournit de manière standard une quantité non négligeable de conteneurs prévus pour fonctionner avec n'importe quoi... Il serait dommage de se priver de les utiliser.

En effet, la proposition de ZouBi, pour correcte qu'elle soit, présente l'énorme inconvénient... de te forcer à gérer toi même la mémoire, à la manière de ce qui se fait en C.

Il faut savoir que, en C++, on préfère réserver l'utilisation des pointeurs et de l'allocation dynamique de la mémoire aux quelques cas dans lesquels on est réellement obligé de les utiliser.

En l'occurrence, la gestion des éléments d'un conteneur n'est pas un cas d'obligation

Aussi, ainsi que Sylvain Togni l'a fait valoir, tu devrais t'intéresser très sérieusement aux différents conteneurs de la STL.

Profites-en pour réfléchir éventuellement au fait qu'un tableau présente un avantage lorsqu'il s'agit d'avoir un acces direct (aléatoire) aux différents éléments, mais présente des inconvénients majeurs en ce qui concerne l'accès séquentiel, l'ajout ou la suppression d'éléments.

D'autres conteneurs fournissent des accès séquentiels qu'il pourrait s'avérer intéressant pour toi d'utiliser

[JolyLoic]

Je ne connais pas std::vector ni la méthode erase(), pour l'utiliser il faut que mes objets héritent d'un classe en particuliere?

Non, pas besoin. Il faut juste que tes objets soient correctement copiables.

En gros, ton code s'écrirait ainsi :

Code :

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

1
2
std::vector<maClasse> tableau(5);
tableau.erase(tableau.begin() + n);

Erase prend en paramètre ce qu'on appelle un itératuer, sui est une sorte de pointeur à l'intérieur d'un tableau, tableau.begin() retourne l'itérateur sur le premier élément, et le +n le fait avancer de 5 cases.

[Luc Hermitte]

Je ne peux également que te conseiller vivement de t'intéresser vivement au vecteurs et autres éléments de la bibliothèque standard du C++.

Accessoirement, si les objets initiaux sont bien copiables/affectables, sans sortir le memmove qui ne comprend rien aux objets, il y a std::copy tout simplement pour s'épargner la boucle à la main. Suivant les propriétés de tes objets, il y a moyen de s'y prendre encore autrement (en jouant avec swap p.ex.).

Après, est-ce que tes objets sont copiables ou non ? ... Tu es le seul à pouvoir le savoir. (NB: si ce sont des objets entité tirés d'une hiérarchie p.ex., il y a de fortes chances qu'ils n'aient pas à être copiables ; il te faudra alors passer par une couche intermédiaire de pointeurs alors)