Discussion :

[Merillym]

Bonjour,

Je n'arrive pas vraiment à trouver la source du problème, je présume que le problème vient de la taille du tableau, mais aucune certitude. Ou alors une mauvaise utilisation de realloc ?

On va prendre un exemple :

Code :

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

data[] = "aaa\\0zzz\\0\\0";

La taille de data est donc bien de 12+1.

Le but est d'obtenir tableau de telle sorte que :

tableau[0] = a
tableau[1] = a
tableau[2] = a
tableau[3] = '\0'
tableau[4] = z
tableau[5] = z
tableau[6] = z
tableau[7] = '\0'
tableau[8] = '\0'

Le but est donc de remplacer le \ et le 0 par '\0'. La taille de tableau est donc égale à la taille de data, caractère nul non compris, donc ici 12, moins le nombre de fois ou l'on rencontre à la suite les deux caractères \ et 0 dans la chaîne data, soit 3 ici : d'où taille de tableau = 9.

J'ai codé la fonction suivante...

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
36
   int b = -1;
            int taille = 0;
            int count = 0;
 
            char *tableau = NULL;
 
            if ((tableau = (char*)malloc(COMPTER_CH(data))) == NULL)
            {
                printf("Erreur d'allocation mémoire !\n");
            }
 
            while (++b <= COMPTER_CH(data)-count)
            {
                if (data[b] == '0' && data[b-1] == '\\')
                {
                    continue;
                }
 
                if (data[b] == '\\' && data[b+1] =='0')
                {
                    if ((tableau = realloc(tableau, COMPTER_CH(data)-(++count))) != NULL)
                    {
                        tableau[taille] = '\0';
                        taille += 1;
                    }
                    else
                    {
                        printf("Erreur d'allocation mémoire !\n");
                    }
                }
                else
                {
                tableau[taille] = data[b];
                taille += 1;
                }
            }

Elle n'est pas bien codé... je suis preneur de conseils à ce niveau au passage.

En testant avec des printf ça donne :

taille de tableau = 12
b = 0
tableau[0] = a
b = 1
tableau[1] = a
b = 2
tableau[2] = a
b = 3
taille de tableau = 11
tableau[3] = <null>
b = 4
b = 5
tableau[4] = z
b = 6
tableau[5] = z
b = 7
tableau[6] = z
b = 8
taille de tableau = 10
tableau[7] = <null>
b = 9
b = 10
taille de tableau = 9
tableau[8] = <null>

Le résultat est... bon.

Seulement, quand j'envoie tableau à RegSetValueEx, dans le registre, j'obtiens ça :

61,00,61,00,61,00,00,00,7a,00,7a,00,7a,00,00,00,00,00,4c,00,
41,00,54,00,46,00,4f,00

La valeur en vert correspond à aaa<null>zzz<null><null> et l'autre à des caractères non voulus... qui viennent de je ne sais où.

Je ne comprends pas pourquoi j'ai ici ces caractères en trop... je présume que mon tableau ne fait pas 9 en taille, mais bien plus... mais je n'arrive pas à trouver pourquoi j'obtiens un tel résultat...

Merci par avance de votre aide.

Je cherche depuis 2 bonnes heures, en reprenant à zéro à chaque fois, mais sans succès jusqu'à présent. J'ai dû me planter dans mes compteurs et l'incrémentation de mes variables...

[SofEvans]

peut-on avoir le code de COMPTER_CH().

Je ne connais pas cette fonction mais je ne crois pas qu'elle vienne d'une librairie. Si elle vient d'une librairie, de laquelle vient-elle et que specifie la doc a son propos ?

[Merillym]

Ah oui j'ai oublié de le mettre, c'est une fonction que j'ai codée ( pour m'entraîner j'ai recodé plusieurs fonctions contenues dans string.h ) :

Code :

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

1
2
3
4
5
6
7
8
9
10
int COMPTER_CH(char str[])
{
    int x = 0;
 
    while (str[x] != '\0')
    {
        x++;
    }
    return(x);
}

[SofEvans]

Ok, donc deja, c'est un coup de bol que ton programme marche.

Je t'explique :

Quant tu fais un malloc, il faut indiquer la taille de ton tableau.
Tu fais donc :

Code :

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

1
2
 
malloc(COMPTER_CH(data))

Sauf que cette taille ne correspond pas aux nombre de case dans le tableau. La taille passer correspond au nombre d'octet que tu veux allouer.

Or, les type primitif (int, char, long, double ...) ont un nombre d'octet different, et ce nombre peut meme varier.

Le nombre d'octet sur lequel on peut stocker un char est generalement 1.
pour un int et un long c'est 4 (generalement).
Un douvle c'est 8 (souvent).

Bref, c'est la pagaille. Alors comment dire combien d'octet on veut ?
C'est tout simple :

nombre d'octet a allouer = nombre de case * nombre d'octet du type désiré

on recupere le nombre d'octet du type grace a siezof(type)

Dans ton cas, je ne sais pas si tu savais ce que je t'ai expliqué ou si tu as consciemment supprimer le sizeof, mais il ne faut pas perdre de vue que char peut prendre un nombre d'octet different de 1.

Donc, la "bonne" syntaxe d'un malloc est :

pointeur = (cast du type pointeur) malloc (nombreDeCas *sizeof(typeDeLaVariablePointé);

En gros :

Code :

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

1
2
 
tableau = (char*)malloc(COMPTER_CH(data));

devient

Code :

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

1
2
 
tableau = (char*)malloc(COMPTER_CH(data)*sizeof(char))

Ah, certaine personne disent que le cast sur le retour de malloc n'est pas obligatoire. Je n'ai jamais pris la peine de verifier cette information.


Pour le probleme que tu rencontre, je penche pour le while qui contient un continue, la boucle me semble tres bizarrement codé.


Je me penche sur la question.

[Merillym]

Dans ton cas, je ne sais pas si tu savais ce que je t'ai expliqué ou si tu as consciemment supprimer le sizeof, mais il ne faut pas perdre de vue que char peut prendre un nombre d'octet different de 1.

Oui oui j'en étais conscient Mais ce n'est peut-être pas une bonne habitude à prendre que de simplifier ainsi quand on manipule des données de type char. Je l'ai fait car sizeof(char) ça fait un ^^

Oui je veux bien au final, ici 9 octects, 1 par caractères. Je pars donc de COMPTER_CH(data) = 12 pour tomber à 9. A ce niveau ça me semble bon, mais j'ai pris une mauvaise habitude en raccourcissant ainsi les malloc avec char, donc je vais rectifier ça.

Ah, certaine personne disent que le cast sur le retour de malloc n'est pas obligatoire. Je n'ai jamais pris la peine de verifier cette information.

Ca marche si on compile en C, ce qui est mon cas, mais bon je préfère prendre la bonne habitude. A moins que ça n'en soit pas une bonne...

J'ai testé avec un boucle for aussi, sans succès.

Merci pour tes conseils et ton aide.



edit :

mais il ne faut pas perdre de vue que char peut prendre un nombre d'octet different de 1.

Ah, je ne le savais pas... dans quel cas est-ce possible ?

[SofEvans]

mais il ne faut pas perdre de vue que char peut prendre un nombre d'octet different de 1.

Ah, je ne le savais pas... dans quel cas est-ce possible ?

Je n'en sais absoluement rien

En fait, j'ai lu que les type pouvait etre coder sur un nombre different d'octet.

J'etait quand meme intrigué, alors j'ai demandé a mon prof. Il m'a repondu que c'etait a cause des ancien codage ou quelque chose comme ca et que comme rien n'etait standart la dessus, le sizeof devait etre systematique.

Pour tout t'avouer, j'en suis rester a ce stade, je n'ai pas chercher a approfondire.