"Call Stack" trouvé pendant un débugage

Bonjour,

J'ai voulu raccourci un morceau de code qui ressemblait en gros a sa :

Code:

---

1 2 3 4 5

if(c[63]==longchaine) { c[62]++; c[63]=0; } if(c[62]==longchaine) { c[61]++; c[62]=0; } ... if(c[2]==longchaine) { c[1]++; c[2]=0; } if(c[1]==longchaine) { c[1] = 0; }

---

(Je tiens a préciser qu'avec ce morceau de code ci-dessus mon programme fonctionne parfaitement)

Par ceci :

Code:

---

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

while(continuer2==0) { if(c[i]==longchaine) { c[i]=0; c[i-1]++; } i--; if(i==1) { if(c[1]==longchaine) { c[1] = 0; } continuer2=1; } }

---

(C'est donc ce morceau qui créer un bug, et pourtant...(voir la suite))

Cependant mon programme plante après un moment d'exécution. Je lance donc le Debug sur Code::Blocks et il me trouve un "Call Stack", je vous copie/colle le détail :

Citation:

---

#0 00401580 creation(nomchaine=0x22fdcd "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", longchaine=36) (C:\Chemin_vers_programme\main.cpp:52)
#1 00401D9B main() (C:\Chemin_vers_programme\main.cpp:216)

---

L'endroit de la ligne 52 (pour le 1er Call Stack) correspond a ce morceau de code qui est dans ma fonction "void creation(char *nomchaine, int long chaine)" :

Code:

---

1 2 3 4 5

while(f6<=f5) { fputc(nomchaine[c[f6]], fichier); f6++; }

---

L'endroit de la ligne 216 (pour le 2e Call Stack), dans le main, correspond a l'appel de ma fonction "creation".

Le bug ne provient donc pas du nouveau morceau de code, mais c'est a cause de lui que le bug apparaît...

Quelqu'un aurait une idée d'où peut venir le problème svp ?

Cordialement,

Je pense qu'il va falloir montrer plus de code que ça.
Y compris l'initialisation de i, le contenu de tes variables f5 et f6...

f5 contient la taille de la chaîne qui sera écrite dans mon fichier

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

void creation(char *nomchaine, int longchaine) { int c[63] = {0}; int f5; int f6; int i = 63; char retour = '\n';   f6 = 1; while(f6<=f5) { fputc(nomchaine[c[f6]], fichier); //Ligne qui pose problème quand nouveau morceau de code implanter f6++; } fputc(retour, fichier);   c[f5]++;   i=63; //Début nouveau morceau de code while(continuer2==0) { if(c[i]==longchaine) { c[i]=0; c[i-1]++; } i--; if(i==1) { if(c[1]==longchaine) { c[1] = 0; } continuer2=1; } } //Fin nouveau morceau code } int main() { char un[] = {*plein de caractères*,'\0'}; char deux[] = {*plein de caractères*,'\0'}; char trois[] = {*plein de caractères*,'\0'}; char quatre[] = {*plein de caractères*,'\0'}; int menu = 0; cin >> menu;   if(menu==1) { creation(un,166); } else if(menu==2) { creation(deux,62); } else if(menu==3) { creation(trois,36); } else if(menu==4) { creation(quatre,36); } return 0; }

---

J'ai aussi sa dans le debug :

Citation:

---

Program received signal SIGSEGV, Segmentation fault.
At C:\Chemin_vers_fichier\main.cpp:52

---

Et a la ligne 52 c'est ceci :

Code:

---

fputc(nomchaine[c[f6]], fichier);

---

Donc le problème viendrait de mon pointeur "char *nomchaine" dans "void creation(char *nomchaine, int longchaine);"

c[63] n'est pas une expression valide.

Pourtant c'est dans un autre topic sur ce forum (http://www.developpez.net/forums/d13...s/#post7333757) que l'on m'a dit que cela était possible.
Et c'est ceci qui raccourci la déclaration des mes 63 variables.

Par quoi je pourrai le remplacer dans ce cas ?

Je me suis mal exprimé.

Je voulais dire que c[i] n'est pas valide quand i = 63.
Les indices du tableau vont de 0 à 62.

Ah en effet, je me suis trompé... Je devrais plus commenter mon code...

Merci beaucoup de votre aide :)

Je retire ce que j'ai dis...

Après ta remarque Medinoc j'ai donc modifier mon code et principalement mon

Code:

---

c[63] = {0};

---

comme ceci :

Code:

---

c[longchaine] = {0};

---

Cependant une erreur apparaît au moment de la compilation :

Citation:

---

C:\Chemin_vers_fichier\main.cpp|10|error: variable-sized object 'c' may not be initialized|

---

Je pense que c'est parce que le compilateur ne connaît pas la variable "longchaine" au moment de la compilation, mais je ne suis pas sur. Si c'est ça, comment résoudre ce problème ?

Avec l'allocation dynamique (new[]) ou en utilisant un std::vector<int> au lieu de ton tableau.

Avec un

Code:

---

vector<int> c(longchaine,0);

---

cela ne fonctionne pas visiblement car j'ai toujours l'erreur au niveau du :

Code:

---

1 2	f1 = longchaine; fputc(nomchaine[c[f1]], fichier);

---

Pour l'allocation dynamique je ne sais pas comment ça fonctionne. J'ai regarder le principe de fonctionnement et j'ai essayé ça :

Code:

---

int *c = new int[longchaine];

---

Mais sans succès, encore la même erreur qu'au dessus.

Peut-être ai-je fais une erreur quelque part ?

Code:

---

1 2 3

vector<int> c(longchaine,0); f1 = longchaine; fputc(nomchaine[c[f1]], fichier);

---

Le vector a une longeur de longchaine en indice de base 0, donc c[longchaine] est invalide (après la fin du vector...)

Dans ce cas le vector n'est pas adapté à mon programme puisque je suis obligé de mettre :

Code:

---

1 2	f1 = longchaine; fputc(nomchaine[c[f1]], fichier);

---

Dans mon programme pour qu'il réalise la fonction voulue.

pour que c[longchaine] soit défini il suffit de déclarer:

Code:

---

std::vector c(longchaine+1,0)

---

Par ailleurs, que cherches tu à faire?
Parce que là, ce que tu vas faire c'est écrire le premier caractère de la chaine (tu remplis ton vector de 0) un nombre indéfini de fois (int f5; --> f5 contient n'importe quoi...donc ton while f6<=f5 fera n'importe quoi) jusqu'à ce que ton itération t'amène à un indice invalide qui plante tout...

Ce que je cherche à faire c'est écrire les c[longchaine] caractères du char sélectionné par l'utilisateur dans le fichier texte.

Je veux qu'il y ait c[longchaine] initialisé pour que le nombre de c[] correspondent aux nombres de caractères qu'il y a dans le char qui a été choisie par l'utilisateur.

Chaque c[] au début contient le premier caractère du char choisie. Puis au fur et a mesure des boucles le dernier c[] est incrémenté et dès que celui-ci atteins longchaine on incrémente le c[] précédent puis on met le c[] qui viens d'atteindre longchaine a 0. Et ceci jusqu'à ce que c[1] atteigne longchaine, et la le programme se termine.


J'ai oublié de mettre un bout de code mais f5 contient la taille de la chaîne qui va être généré (de 8 à 63 caractères), aucun rapport avec les char contenant les chaînes de caractères.

C'est donc ce morceau de code qui a pour but d'écrire ces caractères dans le fichier texte

Code:

---

1 2 3 4 5 6 7 8 9

f6 = 0; f1 = longchaine; while(f6<=f5) { fputc(nomchaine[c[f1]], fichier); f1--; f6++; } fputc(retour, fichier);

---

Et ceci incrémente le denier caractère :

Code:

---

1 2	f1=longchaine; c[f1]++;

---

Et le morceau suivant vérifie si un c[] a atteins longchaine :

Code:

---

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

while(continuer2==0) { if(c[i]==longchaine) { c[i]=0; c[i-1]++; } i--; if(i==1) { if(c[1]==longchaine) { c[1] = 0; } continuer2=1; } }

---

A mon humble avis, tu te compliques la vie.
En c++, je dirais que ça s'écrit:

Code:

---

1 2 3 4 5 6 7

#include <fstream> ...reste du code void creation(const char * const nomchaine, const char* const nomfichier){ std::ofstream fichier(nomfichier); fichier<<nomchaine<<std::endl; }

---

Si veux en savoir plus, tu peux aller voir par là, par exemple:
http://www.cplusplus.com/reference/fstream/

Oui mais la le code que tu me propose la va écrire directement toute la chaîne dans le fichier si j'ai bien compris ?

Et ce n'est pas ce que je veux ^^

Ton code va écrire ceci dans le fichier:

Code:

---

1 2 3 4 5 6 7 8

A B C D ... 8 9 0

---

Or moi je veux que mon code fasse ceci :

Code:

---

1 2 3 4 5 6 7

AAAAAAAA AAAAAAAB AAAAAAAC ... AAAAAAA9 AAAAAAA0 AAAAAABA

---

EDIT : Je me suis rendu compte que quand je ne lançais pas le debug, mais que je lançais le programme celui-ci tournais un moment en écrivant comme il faut dans le fichier mais qu'entre temps nomchaine changeait....

Citation:

---

Envoyé par Iron-Avenger

Ton code va écrire ceci dans le fichier:

Code:

---

1 2 3 4 5 6 7 8

A B C D ... 8 9 0

---

---

en fait, non, il va écrire la chaîne tout bêtement. JE n'avais pas capté que tu faisais de la combinatoire :aie:
Concernant le dimensionnement, vector ou tableau il faut que tu retiennes que les indices étant en base 0, si tu utilises la dimension n les indices valides sont dans [0;n-1]. Par conséquent si tu veux que ton tableau ou vector ait un emplacement valide d'indice longeurchaine, il faut le dimensionner à longeurchaine+1.
Mais ça irait aussi bien en initialisant à 0 et en s'arrêtant à longeurchaine-1
C'est la raison de tes plantages: des dépassement d'indices qui t'amènent dans des parties de la mémoire non initialisées et là comme tu utilises des indices pour récupérer des indices tu as très vite des résultats...explosifs
Dans l'ensemble je dirais que tu devrais réfléchir à ton algorithme global, à mon avis il y a moyen de l'écrire de manière plus simple et donc plus facile à comprendre et à débugger.

Je vais réfléchir à ça.

Sinon, quitte à vouloir écrire du C++, pourquoi ne pas en écrire pour de vrai ?

Déjà qu'en C je trouve limite l'utilisation de fputc alors qu'on a fwrite, mais en C++ on a carrément les stream qui surchargent les opérateurs >> et << qui font ça encore mieux.

J'ai déjà essayer, mais l'erreur est au même niveau :

Code:

---

fichier << nomchaine[c[f6]];

---

Oui, l'erreur est la même pour la même raison: des échafaudages d'indice calculés par indice qui sont très difficiles à contrôler correctement et mènent à des accès mémoire illégaux...

Je viens de remarquer qu'avant que mon programme plante il écrit bien dans le fichier. Mais j'ai remarqué aussi qu'il écrivait TOUTES les chaînes de caractères, puis qu'après il y avait plein de caractères spéciaux (contenu dans mes chaînes) écrit dans un ordre totalement aléatoire...

Je ne suis pas certain d'avoir bien compris ce que tu essaye de faire... Est-ce que tu veux que si l'utilisateur a entré "ABC", tu affiches :

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

AAA AAB AAC ABA ABB ABC ACA ACB ACC BAA BAB BAC BBA BBB BBC BCA BCB BCC CAA CAB CAC CBA CBB CBC CCA CCB CCC

---

?

Si oui, est-tu conscient qu'avec la chaîne en entrée dont tu parles, de 36 caractères, tu parles d'un fichier de 36^36 lignes, soit 36^36 * 37 caractères, soit environ 4E57, à peu près autant qu'il y a d'atomes dans le soleil... J'espère que tu as un bon disque dur :)

Si non, peux-tu montrer l'ensemble de la sortie que tu attends dans ce cas ?

Non je ne souhaite pas faire ça. En faite le but est de faire un dictionnaire de mot de 8 à 63 caractères contenant soit :
1) 94 caractères ASCII
2) Les lettres de l'alphabet (MAJ et min) + chiffres
3) Les lettres de l'alphabet (MAJ) + chiffres
4) Les lettres de l'alphabet (min) + chiffres

Je sais que pour tout cela, ça ferai des milliards de milliards de To de place (8^94+9^94+10^94+...+63^94 pour le 1er dictionnaire).
Mais le but étant de contenir tout cela dans une suite de fichier, et qu'il n'y aurai que 3 fichiers d'environ 90Mo sur le disque dur.

J'ai tenter avec le code ASCII des caractères, mes chaînes ressemblent sont donc une suite du code ASCII des lettres de l'alphabet min et/ou maj et/ou chiffres et/ou caractères spéciaux.

Donc je veux que, par exemple, pour la chaîne n°3 si l'utilisateur a choisi de commencer a 8 caractères, cela écrive :

Code:

---

1 2 3 4 5 6 7 8 9 10

AAAAAAAA AAAAAAAB AAAAAAAC AAAAAAAD ... AAAAAAA9 AAAAAAA0 AAAAAABA ... (jusqu à) 0000000000000000000000000000000000000000000000000000000000000000

---

Je n'ai pas trop compris ce que tu dis, puisque d'un côté tu dis que c'est bien trop gros (et je suis d'accord avec toi), pour ensuite dire que ça tient dans une suite de fichiers (et là, je ne le suis plus trop...)

Toujours est-il que sur des petits "mots", dans le cas de ton ensemble 3 par exemple, il faut voir que ton énumération consiste simplement à compter de 0 à 36^8 en base 36.

Voici un bout de code, non optimisé, qui fait ça (attention, rien que pour une valeur de 4 avec ton alphabet de 36 caractères, on obtient un fichier de 10Mo...)

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45

#include <iostream> #include <string> #include <fstream>   using namespace std;   long long pow(int a, int b) // return a^b { long long result = 1; for (int i=0 ; i<b ; ++i) { result *= a; } return result; }   string toStringInBase(long long nb, std::string const &alphabet, int wordSize) { string revertResult; int base = alphabet.size(); for (int i = 0 ; i<wordSize ; ++i) { int modulo = nb % base; revertResult.push_back(alphabet[modulo]); nb /= base; } return string(revertResult.rbegin(), revertResult.rend()); }   int main() { string alphabet; cout << "Alphabet : "; cin >> alphabet; cout << "Taille du mot : "; int wordSize; cin >> wordSize; int const nbChars = alphabet.size(); long long nbIter = pow(alphabet.size(), wordSize); ofstream resultFile("Result.txt"); for (long long i = 0 ; i<nbIter ; ++i) { resultFile << toStringInBase(i, alphabet, wordSize) << endl; } }

---

Citation:

---

Envoyé par Iron-Avenger

Je viens de remarquer qu'avant que mon programme plante il écrit bien dans le fichier. Mais j'ai remarqué aussi qu'il écrivait TOUTES les chaînes de caractères, puis qu'après il y avait plein de caractères spéciaux (contenu dans mes chaînes) écrit dans un ordre totalement aléatoire...

---

Oui car quand tu débordes de ton tableau ça se met à utiliser des indices venant d'une partie de la pile d'appel qui n'est pas ton tableau, et qui ont donc des valeurs complètement farfelues.
Puis comme tu écris à ces indices farfelus tu commences à labourer sauvagement des espaces mémoire choisis au hasard, jusqu'à ce que ça tappe dans une adresse qui t'es interdite ou que ça commence à faire n'importe quoi parce que tes variables locales sont corrompues...alors là ça finit par planter

Citation:

---

Envoyé par JolyLoic

Je n'ai pas trop compris ce que tu dis, puisque d'un côté tu dis que c'est bien trop gros (et je suis d'accord avec toi), pour ensuite dire que ça tient dans une suite de fichiers (et là, je ne le suis plus trop...)

---

En faite ce programme permet de générer un dictionnaire (ça j'ai déjà dit) qui sera utilisé par un autre programme pour faire quelque chose. Cet autre programme scanne les fichiers un par un.

J'ai donc décidé qu'au bout du 3e fichier, mon programme ce met en pause et attend que l'utilisateur donne son accord pour commencer la création du 4e fichier, mais va détruire le 1er fichier.

Ce qui fait que tout ce dictionnaire tiendrait dans maximum 3 fichiers au total.

Citation:

---

Envoyé par JolyLoic

Toujours est-il que sur des petits "mots", dans le cas de ton ensemble 3 par exemple, il faut voir que ton énumération consiste simplement à compter de 0 à 36^8 en base 36.

Voici un bout de code, non optimisé, qui fait ça (attention, rien que pour une valeur de 4 avec ton alphabet de 36 caractères, on obtient un fichier de 10Mo...)

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45

#include <iostream> #include <string> #include <fstream>   using namespace std;   long long pow(int a, int b) // return a^b { long long result = 1; for (int i=0 ; i<b ; ++i) { result *= a; } return result; }   string toStringInBase(long long nb, std::string const &alphabet, int wordSize) { string revertResult; int base = alphabet.size(); for (int i = 0 ; i<wordSize ; ++i) { int modulo = nb % base; revertResult.push_back(alphabet[modulo]); nb /= base; } return string(revertResult.rbegin(), revertResult.rend()); }   int main() { string alphabet; cout << "Alphabet : "; cin >> alphabet; cout << "Taille du mot : "; int wordSize; cin >> wordSize; int const nbChars = alphabet.size(); long long nbIter = pow(alphabet.size(), wordSize); ofstream resultFile("Result.txt"); for (long long i = 0 ; i<nbIter ; ++i) { resultFile << toStringInBase(i, alphabet, wordSize) << endl; } }

---

---

Dans le cas de mon 3e exemple on compte de 0 à 36^63 ! Pas 36^8.

Citation:

---

Envoyé par therwald

Oui car quand tu débordes de ton tableau ça se met à utiliser des indices venant d'une partie de la pile d'appel qui n'est pas ton tableau, et qui ont donc des valeurs complètement farfelues.
Puis comme tu écris à ces indices farfelus tu commences à labourer sauvagement des espaces mémoire choisis au hasard, jusqu'à ce que ça tape dans une adresse qui t'es interdite ou que ça commence à faire n'importe quoi parce que tes variables locales sont corrompues...alors là ça finit par planter

---

Mais comment c'est possible de déborder de mon tableau ? J'ai pourtant bien mis le bon nombre de caractères...

Et quand j'ai ce morceau de code la :

Code:

---

1 2 3 4 5 6

if(c[63]==longchaine) { c[62]++; c[63]=0; } if(c[62]==longchaine) { c[61]++; c[62]=0; } etc... if(c[2]==longchaine) { c[1]++; c[2]=0; } if(c[1]==longchaine) { c[0]++; c[1] = 0; } if(c[0]==longchaine) { c[0]=0; }

---

Mon programme fonctionne parfaitement...

Donc c'est que c'est ce morceau de code qui pose problème :

Code:

---

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

i=longint; while(continuer2==0) { if(c[i]==longint) { c[i]=0; c[i-1]++; } i--; if(i==0) { if(c[0]==longint) { c[0] = 0; } continuer2=1; } }

---

Citation:

---

Envoyé par Iron-Avenger

Mais comment c'est possible de déborder de mon tableau ? J'ai pourtant bien mis le bon nombre de caractères...

Et quand j'ai ce morceau de code la :

Code:

---

1 2 3 4 5 6

if(c[63]==longchaine) { c[62]++; c[63]=0; } if(c[62]==longchaine) { c[61]++; c[62]=0; } etc... if(c[2]==longchaine) { c[1]++; c[2]=0; } if(c[1]==longchaine) { c[0]++; c[1] = 0; } if(c[0]==longchaine) { c[0]=0; }

---

---

l'erreur de borne entre lonchaine et longchaine-1 suffit à aller lire une valeur située après le tableau et dont la valeur n'a ni queue ni tête...effet boeuf garanti. Si le tableau est en fin de pile c'est de la mémoire non initialisée, mais même dans le cas contraire ça n'a aucune raison d'être un indice valide.

Citation:

---

Envoyé par therwald

L'erreur de borne entre lonchaine et longchaine-1 suffit à aller lire une valeur située après le tableau et dont la valeur n'a ni queue ni tête...effet boeuf garanti. Si le tableau est en fin de pile c'est de la mémoire non initialisée, mais même dans le cas contraire ça n'a aucune raison d'être un indice valide.

---

Mais ce que je ne comprend pas c'est comment il peux y avoir une erreur de borne ou que le programme change de chaîne de caractères étant donner que j'ai spécifié des valeurs précises qui correspondent au nombre exacte de valeur dans chaque chaîne de caractères, et que j'ai fait des chaînes de caractères précises distincte ?

Peut-être parce que certaines valeurs se retrouvent dans toutes mes chaînes ?

Il n'y a pas un moyen pour palier à ce problème ?

le fait d'aller lire ne serais-ce qu'un rang après la fin d'un tableau te fait des indices imprévisibles...quand au fait d'écrire, qui sait ce qui peut arriver? avec "un peu de bol" tu réinitialise ta variable f6 à 1235778 et vlan...ou alors tu change la valeur de ton pointeur de chaine, bref impossible de savoir...écrire "à côté" d'une variable c'est "undefined behavior", plus rien n'est garanti...

Par ailleurs, je maintiens qu'il faudrait que tu exprimes ton algorithme de manière plus structurée, et de préférence plus simple, pour le rendre plus facile à maîtriser.
Inspire toi de ce que JolyLoic a proposé.

Très bien dans ce cas je vais revoir la structure de mon algorithme.

Merci beaucoup de votre aide (je met en "Résolu") :)