Insérer (template)

Version imprimable

Insérer (template)

Bonjour

Comment inserer un element ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <class T>
class TableDyno
{
public:
 
    TableDyno(int capacity = 4);
 
private:
 
    int            capacity;
    int            nbElements;
    T*             indice;
};
 
void inserer(const T& element, int index) {
 
  ???
}

05/11/2022, 12h35
deedolith

Salut,

Pourquoi n'utilises-tu pas un conteneur adapté plutôt que ce pointeur brut tout moisi ?
Tu pourras profiter de la toute-puissance de la librairie standard (STL), et t'éviter de nombreuses prises de tête / erreurs due à ta gestion de la mémoire "manuelle".

Ensuite, une capacité et un index ne peuvent être négatifs, alors utilise un type de donnée adapté: unsigned ou encore mieux, le type fournis par la STL: std::size_t.

Enfin, si tu tiens à conserver les pointeurs brut, il n'y a pas 36 solutions, j'assume que indice (quel nom mal choisi) est un tableau:
- Instancier un nouveau tableau suffisamment grand pour accueillir une nouvelle valeur.
- Recopier les valeurs de indice vers le nouveau tableau.
- Copier la nouvelle valeurs dans un emplacement disponible.
- Detruire le contenu d'indice.
- Detruire indice.
- Faire pointer indice sur le nouveau tableau.
toute une série d'instructions que std::vector (par exemple) fait en une seule ligne de code.
05/11/2022, 12h39
koala01

Salut,

en gros, mais sans te donner de code (parce que ce serait trop facile du coup :D)
1- t'assurer que l'indice fourni soit valide, en vérifiant qu'il soit bien compris dans l'intervale [<indice du premier élément>, <indice du dernier élément>]. Si ce n'est pas le cas, c'est une erreur de logique de la part de la personne qui a fait appel à la fonction, et il faudra donc l'avertir avant d'arrêter le massacre
2- t'assurer que la capacité de ton tableau est suffisante pour permettre l'ajout de l'élément à insérer. Si ce n'est pas le cas, il faudra augmenter cette capacité
3- décaler "d'un cran" tous les élément qui suivent l'indice auquel tu souhaite insérer le nouvel élément, en t'assurant bien sur de n'en perdre aucun
4- ajouter l'élément à insérer à l'endroit où il est censé prendre place.

Note que certaines de ces étapes nécessiteront plusieurs instructions, voire peut-être même une boucle afin de pouvoir être exécutées. Je te laisse maintenant réfléchir au moyen de mettre tout cela en oeuvre ;)

Citation:

Envoyé par deedolith

Salut,

Pourquoi n'utilises-tu pas un conteneur adapté plutôt que ce pointeur brut tout moisi ?
Tu pourras profiter de la toute-puissance de la librairie standard (STL), et t'éviter de nombreuses prises de tête / erreurs due à ta gestion de la mémoire "manuelle".

Ensuite, une capacité et un index ne peuvent être négatifs, alors utilise un type de donnée adapté: unsigned ou encore mieux, le type fournis par la STL: std::size_t.

Enfin, si tu tiens à conserver les pointeurs brut, il n'y a pas 36 solutions, j'assume que indice (quel nom mal choisi) est un tableau:
- Instancier un nouveau tableau suffisamment grand pour accueillir une nouvelle valeur.
- Recopier les valeurs de indice vers le nouveau tableau.
- Copier la nouvelle valeurs dans un emplacement disponible.
- Detruire le contenu d'indice.
- Detruire indice.
- Faire pointer indice sur le nouveau tableau.
toute une série d'instructions que std::vector (par exemple) fait en une seule ligne de code.
Code:

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 Merci )) Si je fais cela, serait-il correct? template <class T> class TableDyno { public: TableDyno(int capacity = 4); private: int capacity; int nbElements; T* indice; }; void inserer(const T& element, int index) { int *temp = new int[index] ; for(int i =0; i<capacity; i++) { if(indice[i]==index[i]) { temp[i] = index; delete[] temp; temp[nbElements] = index; nbElements++; delete[] indice; }

05/11/2022, 17h55
dalfab
Non, tu as dû voir que ça ne compile pas.

La fonction doit être définie comme:
Code:

1 2 template<class T> void TableDyno<T>::inserer(const T& element, int index) { ...

Salut,

Tes noms de variable sont confus.
nbElement, capacity, ca désigne la même chose.
Tu confonds index et capacité., je dirais même que tu confonds tout.

Le mieux, tant que ta classe est petite, c'est de repartir sur une base saine.
D'ailleur, commence par t'occuper du constructeur et du destructeur.
Code:

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 template <class T> class DynamicTable { public: DynamicTable(std::size_t capacity = 4); ~DynamicTable(); void insert(const T& element, std::size_t index); private: std::size_t mCapacity; T* indice; }; template <class T> DynamicTable<T>::DynamicTable(std::size_t capacity): mCapacity{ capacity } { // A compléter } template <class T> DynamicTable<T>::~DynamicTable() { // A Completer } template <class T> void DynamicTable<T>::insert(const T& element, std::size_t index) { // A Completer }
PS: Quand tu nommes quelque chose, évite les sobriquets.

Citation:

Envoyé par deedolith

Salut,

Tes noms de variable sont confus.
nbElement, capacity, ca désigne la même chose.
Tu confonds index et capacité., je dirais même que tu confonds tout.

Le mieux, tant que ta classe est petite, c'est de repartir sur une base saine.
D'ailleur, commence par t'occuper du constructeur et du destructeur.

Code:

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
template <class T>
class DynamicTable
{
public:
    DynamicTable(std::size_t capacity = 4);
    ~DynamicTable();
    void insert(const T& element, std::size_t index);
 
private:
    std::size_t mCapacity;
    T* indice;
};
 
template <class T>
DynamicTable<T>::DynamicTable(std::size_t capacity):
    mCapacity{ capacity }
{
    // A compléter
}
 
template <class T>
DynamicTable<T>::~DynamicTable()
{
    // A Completer
}
 
template <class T>
void DynamicTable<T>::insert(const T& element, std::size_t index)
{
    // A Completer
}

PS: Quand tu nommes quelque chose, évite les sobriquets.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Merci..
 
Je comprend que les nomminations sont bidons, l'essentiel pour moi est de trouver le bon code pour inserer les elements. 
 
Tout ce qui est en haut est completé, il faut juste inserer les elements et les enlever plus tard. 
 
Le code ci-dessous compile justement, mais rien ne se passe
 
void inserer(const T& element, int index) {
 
   int *temp = new int[index] ; 
        for(int i =0; i<capacity; i++)
        {
            if(indice[i]==index)
          {
             temp[i] = index;
    delete[] temp;
    temp[nbElements] = index;
    nbElements++;
    delete[] indice;

05/11/2022, 20h31
Nigush
Citation:

Envoyé par koala01

Salut,

en gros, mais sans te donner de code (parce que ce serait trop facile du coup :D)
1- t'assurer que l'indice fourni soit valide, en vérifiant qu'il soit bien compris dans l'intervale [<indice du premier élément>, <indice du dernier élément>]. Si ce n'est pas le cas, c'est une erreur de logique de la part de la personne qui a fait appel à la fonction, et il faudra donc l'avertir avant d'arrêter le massacre
2- t'assurer que la capacité de ton tableau est suffisante pour permettre l'ajout de l'élément à insérer. Si ce n'est pas le cas, il faudra augmenter cette capacité
3- décaler "d'un cran" tous les élément qui suivent l'indice auquel tu souhaite insérer le nouvel élément, en t'assurant bien sur de n'en perdre aucun
4- ajouter l'élément à insérer à l'endroit où il est censé prendre place.

Note que certaines de ces étapes nécessiteront plusieurs instructions, voire peut-être même une boucle afin de pouvoir être exécutées. Je te laisse maintenant réfléchir au moyen de mettre tout cela en oeuvre ;)
Code:

1 2 3 Merci, J'ai les presque mêmes instructions, mais comment implémenter, c'est ça la question.
05/11/2022, 20h41
deedolith

Normal, tu fais n'importe quoi.

Tu commences par allouer un espace mémoire de la taille de l'emplacement où tu veux faire l'insertion.
Ce n'est pas ce qu'on t'as indiqué.

Vu que le point de départ est faux, il est inutile de commenter la suite, ça n'a pas de sens.

Citation:

Je comprend que les nomminations sont bidons, l'essentiel pour moi est de trouver le bon code pour inserer les elements.

Le but premier d'un code source est d'être lisible et compréhensible.
Produire le résultat attendu n'arrive qu'en seconde position.
De plus, si aujourd'hui, tu comprends parfaitement ce que tu fais, car tu l'as en tête, mais dans un mois ? un an ? deux ans ? Tu seras incapable de t'y retrouver.
C'est un exercice difficile au début, mais ça fait partie des bonnes habitudes à prendre le plus tôt possible.

Citation:

Tout ce qui est en haut est completé, il faut juste inserer les elements et les enlever plus tard.

au vue de ta copie actuelle, je suis curieux de voir ça.

PS: n'oublies pas que tu travailles avec un template.
07/11/2022, 18h23
Bousk

Après vider, insérer. C'est quoi l'opération suivante ?
C'est bien tenté de nous faire résoudre ton exercice 1 question et 1 sujet à la fois, mais ça se voit un peu.
Si tu manques autant de base, (re)lis ton cours. :roll:

Pour insérer un élément dans un tableau dynamique, la première chose à faire c'est de s'assurer d'avoir la place.
Vu que tu as taille et capacité séparées (c'est bien, ça permet d'éviter de réallouer à chaque insertion) tu vas avoir besoin d'une fonction membre dédiée:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void EnsureCapacity(int newCapacity)
{
	if(capacity >= newCapacity) { return; }
	newCapacity = RoundCapacityUp(newCapacity); //Tu peux faire n'importe quoi ici pour s'assurer d'augmenter de plus de 1; par exemple arrondir aux 16 supérieurs ou au multiple supérieur de la capacité actuelle...
 
	T* tmpArray = new T[newCapacity];
	std::copy(indice, indice+nbElements, newArray); //On copie juste la partie "valide" du tableau
	std::swap(indice, tmpArray);
	capacity = newCapacity;
	delete[] tmpArray;
	//Note: On peut probablement faire quelque chose de plus exception-safe avec un std::unique_ptr<T[]>, mais je ne sais plus comment ça interagit avec swap().
}
 
//Avec ça, on peut faire l'insertion facilement:
void inserer(const T& element, int index) {
	if(index<0 || index >= nbElements+1)
		throw std::out_of_range();
	EnsureCapacity(nbElements+1);
 
	std::copy_backward(indice+index, indice+nbElements, indice+nbElements+1);
	indice[index] = element;
}

C'est important de décomposer le problème.

08/11/2022, 18h03
deedolith

@Medinoc:
Une fonction appelée EnsureCapacity, qui augmente la capacité du tableau et ajoute un élément, bof ...
D'une part, elle viole le SRP.
D'autre part, son nom fait plus penser à une vérification de capacité qu'autre chose.
15/11/2022, 10h32
Médinoc

Citation:

Envoyé par deedolith

@Medinoc:
Une fonction appelée EnsureCapacity, qui augmente la capacité du tableau et ajoute un élément, bof ...
D'une part, elle viole le SRP.
D'autre part, son nom fait plus penser à une vérification de capacité qu'autre chose.

Euh, quoi?
Elle n'ajoute pas d'élément, c'est inserer() qui ajoute l'élément après avoir appelé EnsureCapacity()...

Comment ajouter les strings contenus dans un fichier txt dans un tableau générique ?

Bonjour. Ci-dessous mon code.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Etudiant etudiant; string contenu; fichier >> contenu; TableauDynamique<Etudiant>etudiants; while(fichier >> etudiant) { etudiants.ajouter(etudiant); } for(int i = 0; i < etudiants.taille(); i++) { cout << etudiants[i] << endl; }
Je ne vois que 80% du résultat. Dans le fichier.txt est contenu les renseignements sur l'étudiant.

Je ne sais pas ce qui peut cacher l'affichage complet des renseignements.

Merci :heart:

22/11/2022, 13h59
Médinoc

Ben déjà il ressemble à quoi ton fichier texte?