Discussion :

[Nigush]

Bonjour

Comment inserer un element ?

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
template <class T>
class TableDyno
{
public:
 
    TableDyno(int capacity = 4);
 
private:
 
    int            capacity;
    int            nbElements;
    T*             indice;
};
 
void inserer(const T& element, int index) {
 
  ???
}

[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.

[koala01]

Salut,

en gros, mais sans te donner de code (parce que ce serait trop facile du coup )
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

[Nigush]

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 :

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
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;
}

[dalfab]

Non, tu as dû voir que ça ne compile pas.

La fonction doit être définie comme:

Code :

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

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

[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 :

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
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.

[Nigush]

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 :

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
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 :

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
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;

[Nigush]

Salut,

en gros, mais sans te donner de code (parce que ce serait trop facile du coup )
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 :

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

1
2
3
 
 
Merci, J'ai les presque mêmes instructions, mais comment implémenter, c'est ça la question.

[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.

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.

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.

[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.

[Médinoc]

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 :

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
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.

[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.

[Médinoc]

@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()...

[Nigush]

Bonjour. Ci-dessous mon code.

Code :

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

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

[Médinoc]

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