Tableau dynamique : Initialisation et vérification

Bonjour,




Je cherche à initialiser le plus vite possible un tableau mais :

Code:

---

1 2 3 4 5

int *tableau = NULL;   int taille = 10;   tableau = new int[taille];

---

Avec ce code, les valeurs du tableau ne sont pas à zéro.


Existe-t-il une autre solution que de l'initialiser avec une boucle ?

Code:

---

1 2 3 4

for (int i = 0 ; i < taille ; i++) { tableau[i] = 0; }

---

Et peut-on utiliser la même vérification qu'en C pour prévoir l'échec ?

Code:

---

1 2 3 4 5 6 7

if (tableau == NULL) { cout << "Memoire insuffisante" << endl; delete[] tableau;   system("pause"); }

---

Citation:

---

Envoyé par Nikolas

Existe-t-il une autre solution que de l'initialiser avec une boucle ?

Code:

---

1 2 3 4

for (int i = 0 ; i < taille ; i++) { tableau[i] = 0; }

---

---

Code:

---

1 2 3 4

#include <algorithm>   std::fill_n(tableau, taille, 0); std::fill(tableau, tableau+taille, 0);

---

Note qu'on aura tendance à utiliser des std::vector plutôt que ce genre de tableaux.

Citation:

---

Et peut-on utiliser la même vérification qu'en C pour prévoir l'échec ?

---

Si new échoue, il y a une exception qui est lancée.

Quelle différence entre std::fill_n() et std::fill() ?

Citation:

---

Si new échoue, il y a une exception qui est lancée.

---

C'est-à-dire ? comment je fais pour lancer le message d'erreur à l'utilisateur ?

Citation:

---

Envoyé par Nikolas

Quelle différence entre std::fill_n() et std::fill() ?

---

Les arguments. fill_n prend un nombre, fill un itérateur de fin.

Citation:

---

C'est-à-dire ? comment je fais pour lancer le message d'erreur à l'utilisateur ?

---

Tu apprends à te servir des exceptions.

En langage humain, je comprends que fill modifie les valeurs du tableau en une fois et fill_n revient à utiliser une boucle.


Et concrètement, je ne vois pas comment on fait avec une exception, quant à l'explication sur la FAQ, ça fait plus m'embrouiller que m'aider.

Code:

---

1 2 3 4 5 6 7

if (tableau == NULL) { cout << "Memoire insuffisante" << endl; delete[] tableau;   system("pause"); }

---

Ce code là est donc inutile ?


Mon programme plante et j'ai exclu la possibilité que ça vienne d'une mauvaise allocation mais si cette condition ne sert à rien alors je ne peux plus m'y fier et j'en suis heureux...

Tellement heureux que je devrais buter le chien du voisin pour calmer ma joie, je crois bien.

Citation:

---

Envoyé par Nikolas

En langage humain, je comprends que fill modifie les valeurs du tableau en une fois et fill_n revient à utiliser une boucle.

---

Les deux reviennent plus ou moins à utiliser une boucle.

Citation:

---

Et concrètement, je ne vois pas comment on fait avec une exception, quant à l'explication sur la FAQ, ça fait plus m'embrouiller que m'aider.

---

La FAQ n'est pas un cours ni un bouquin destiné aux débutants.

Citation:

---

Ce code là est donc inutile ?

---

new ne retourne jamais NULL.

Citation:

---

Envoyé par Jean-Marc.Bourguet

Les deux reviennent plus ou moins à utiliser une boucle.

---

Il vaut mieux la boucle si je ne veux pas un programme alourdi d'une bibliothèque de plus, si j'ai bien compris.

Citation:

---

Envoyé par Jean-Marc.Bourguet

new ne retourne jamais NULL.

---

Il retourner quoi en cas d'échec ? pour que je puisse identifier cette erreur...

Citation:

---

Envoyé par Nikolas

Il retourner quoi en cas d'échec ? pour que je puisse identifier cette erreur...

---

Une exception.

Et quelles lignes je dois écrire pour capturer cette exception dans une variable ?

La question étant: si tu n'arrives pas à allouer ton tableau, est-ce que continuer l'exécution de ton programme a encore un sens?

Citation:

---

Il vaut mieux la boucle si je ne veux pas un programme alourdi d'une bibliothèque de plus, si j'ai bien compris.

---

euh. hein? Tout le code que tu vois qui commence par std:: fait partie du langage C++ à part entière, ça n'alourdi rien au contraire ça simplifie.

sinon une exception ça se rattrape comme ça:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

try { // code qui peut lever une exception } catch( const std::exception & e ) { // récupère les exceptions qui héritent de std::exception std::cerr << "exception: " << e.what() << std::endl; } catch( ... ) { //récupère n'importe quelle exception }

---

tu peux spécialiser les catchs suivant le type de l'exception. Un new qui échoue doit renvoyer un std::bad_alloc (sauf compilateur ne suivant pas la norme), tu peux décider d'attraper celle là spécifiquement:

Code:

---

1 2 3 4

catch( const std::bad_alloc & e ) { }

---

La vache, ça me semble être un autre langage. 8O


Je crois que je vais revenir au malloc du C, en espérant qu'il soit compatible avec le C++...




En tout cas merci, les experts !

Citation:

---

Envoyé par Nikolas

Je crois que je vais revenir au malloc du C, en espérant qu'il soit compatible avec le C++...

---

Malloc est fait pour être utilisé avec la partie "compatible" C du C++, le C++ ne connait que "new"

Mais c'est pas grave, non ?


J'ai déjà vu des « rétro commandes » dans des codes.

Citation:

---

Envoyé par Nikolas

Mais c'est pas grave, non ?


J'ai déjà vu des « rétro commandes » dans des codes.

---

Si tu fais du C non. Mais si tu fais du C, pourquoi vouloir faire du C en C++ et pas du C en C?

En C++ on utilise des objets aussi. Et ça le malloc/free ne connaissent pas ( pas d'appel au constructeur ni au destructeur de l'objet )

C'est comme quand tu retiens pas un mot dans une langue étrangère, tu utilises le mot de ta langue natale, tu perds pas de temps. :lol:

Citation:

---

Envoyé par Nikolas

C'est comme quand tu retiens pas un mot dans une langue étrangère, tu utilises le mot de ta langue natale, tu perds pas de temps. :lol:

---

crois moi, ça va pas t'aider

Salut,

Si on a réellement un conseil à te donner, c'est de veiller à utiliser les possibilités du C++ tant que tu peux le faire (ou, à l'inverse, d'éviter d'utiliser les possibilités du C s'il existe un équivalent plus propre et plus sécurisant en C++).

L'idée de mélanger le C et le C++ est en effet la pire que tu puisse avoir:

Le plus souvent, cela t'incitera à réinventer la roue, et à refaire (qui a dit mal :question:) ce que d'autres ont déjà fait de manière bien plus sécurisée et vérifiée.

Ainsi, il est une série d'habitudes prises en C qu'il est urgent d'oublier quand on débute en C++.

Parmi celles ci, on peut citer:

• L'utilisation de char* ou de char[] pour représenter les chaines de caractères (leur préférer l'utilisation de la classe std::string)
• L'utilisation de l'allocation dynamique quand ce n'est pas absolument nécessaire (lui préférer les différents conteneurs existants)
• Le passage systématique d'un pointeur comme argument à une fonction dans laquelle les modifications apportées doivent persister après la fonction (leur préférer les références)
• utiliser malloc et free au lieu de new et delete
• utiliser les fonctions *scanf, *sprintf, str* ...
• surement une ou deux habitudes oubliées ;)

Salut, ça peut paraître terrible de ne pas pouvoir tout initialiser à 0, mais en C on ne peut pas le faire avec malloc (c'est avec calloc).

Tu peux toujours utiliser le memcpy du C, si tu est sûr de ne pas faire d'erreurs, notamment au niveau de la taille.

Note que ce problème ne se pose qu'au niveau des int: Quand tu fais tes propres structures/classes, tu peux choisir de les initialiser comme tu veux.
new n'est ici peut-être pas le meilleur choix, mais quand il s'agit d'initialiser ses propres classes/structures, ça l'est ;)

Avec new T(), T est toujours value-initialized...
Donc y'a pas d'initialisation à faire.

(Remarque: avec GCC, new T value-initialize aussi)