Forum Programmation.c remplir une chaine de int *

Posté par (page perso) .
Tags : aucun
0
8
jan.
2005
Mon but est de convertir un 'long' en une chaine de 'int' et il me semble que mon code ne fait pas du tout ce qui est escompté ; du moins strlen retourne 1 au lieu de 4.

Codes concernés :
unsigned int * long_to_pigendian (unsigned long ze_entier )


{
unsigned int * to_ret;
to_ret=malloc (4*sizeof (unsigned int *));
to_ret[0] =ze_entier / (256*256*256);
ze_entier-=to_ret [0]*(256*256*256);
to_ret[1] =ze_entier / (256*256);
ze_entier-=to_ret [1]*(256*256);
to_ret[2] = ze_entier / (256);
ze_entier-=to_ret [2]*(256);
to_ret[3] = ze_entier;
ze_entier-=to_ret [3];

/* j'ai meme essayé ca ;-) */

to_ret [4]='\0';
return (to_ret);

}




size_t intstrlen (unsigned int * the_string)

{

size_t i =0;
unsigned int * tmp=the_string;
while(*tmp!='\0')
{
*tmp++;
i++;
}

return i;

}


Merci de me donner le petit conseil qui me permettra de repartir du bon pied et d'arreter les erreurs de segmentations :-)
  • # Sacré bazar

    Posté par . Évalué à 3.

    A mon avis, l'erreur est dans la comparaison *tmp!='\0'. *tmp est un int, mais '\0' est un char, à vue de nez, il doit faire une comparaison de chars au lieu d'ints.

    Evite les casts implicites, et essaie avec while(*tmp!=0).

    P.S. : Il n'y aurait pas un autre bogue dans le malloc? Je ne vois pas la raison de l'étoile dans sizeof(unsigned int *).

    Ah, il y a aussi un bogue dangereux dans ta gestion de la mémoire. Il fait effectivement que tu rajoutes un int nul en fin de chaîne, car rien ne garantit que les valeurs qui suivent soient nulles (et donc il faut allouer un espace de plus). Et tu as raison de l'initialiser toi-même à 0, car malloc() n'initialise pas obligatoirement la mémoire. Mais initialise-le donc avec un vrai 0, et non '\0'...

    Ah, et au fait, tu es sûr d'avoir besoin d'une chaine d'ints, et pas de chars? C'est plus courant, tout de même...
    • [^] # Re: Sacré bazar

      Posté par (page perso) . Évalué à 1.

      je sais pas de quel type de chaine j'ai besoin, j'ai juste besoin de stoquer un "long" sur un fichier de 128 octets.

      et donc, je convertis le long en "int".

      j'ai ma fonction write_sur_le_disque_du_data ( fichier, datas)

      mais je lui ai dit d'écrire des "int" (ce qui est peut être un tort ?) et donc, j'aimerais creer des chaines d'entiers pour pouvoir le faire.

      or, des strdup, strcat, c'est bon, mais pas pour les int.

      et les "cast", ça n'avait pas l'air de trop marcher... donc je cherche à refaire les fonctions strcat & strdup avec des "int" et ça chie...
      (ma fonction : unsigned int * long_to_bigendian (unsigned long ze_entier ) (petit lapsus dans le titre :-p ) me permet de faire un struc dans ce gout là , en plus simple( je pensais)

      (en fait rien que "écrire 1 2 3 4 dans un pointeur vers des entiers" me ferrait rêver...)

      merci pour ton aide, je testerai quand je serai chez moi, ce soir.
      • [^] # Re: Sacré bazar

        Posté par . Évalué à 3.

        T'as l'air de faire une jolie salade entre un tableau d'entier (ce que tu veux faire) et une chaine de caractère (qui est un tableau de char).
        Ta fonction strlen fonctionne correctement sur un tableau d'int, par contre ta première fonction remplit ton tableau comme si c'était un tableau de char (et pas un tableau d'int), d'où le souci... La première fonction va probablement foutre un 0 dans tableau[0] si le nb passé en argument n'est pas très grand (plus petit que 256^3)
        • [^] # Re: Sacré bazar

          Posté par (page perso) . Évalué à 1.

          tu résumes bien le bordel : une jolie salade...

          je peux pas faire de tableaux d'int, car c'est fait pour stoquer des megas... voire plus...

          Mais on a tenté de m'expliquer que les tableaux de "int" ne se finissent pas par '\0' = 0, donc que la fonction strlen n'était pas codable... donc je suis retourné aux chaines de "char" et ça roule mieux.

          Merci pour ton aide, [+]
          • [^] # Re: Sacré bazar

            Posté par . Évalué à 2.

            « je peux pas faire de tableaux d'int, car c'est fait pour stoquer des megas... voire plus... »
            « Mais on a tenté de m'expliquer que les tableaux de "int" ne se finissent pas par '\0' = 0, donc que la fonction strlen n'était pas codable... donc je suis retourné aux chaines de "char" et ça roule mieux. »

            Gni ? Je comprends rien du tout à ce que tu racontes... Ce que j'appelle tableau d'int, c'est ce que t'appelle "chaine d'int". Et je vois pas trop ce que ça change de prendre une chaîne de caractère si tu stockes des entiers dedans de la même façon que ta fonction long_to_pigendian. T'auras toujours des 0 qui apparaitront ici ou là plus ou moins aléatoirement. A mon avis la seule solution c'est de stocker la longeur de ta chaîne/tableau dans une variable à part.
      • [^] # Re: Sacré bazar

        Posté par . Évalué à 1.

        Moi je te propose de pas du tout faire comme ça! c'est absolument pas utile de se compliquer à ce point la vie!

        Imaginons plutôt une fonction qui écrit sur le disque avec comme paramètre :

        write_some_data(FILE* file,const void* datas,size_t size){
        fwrite(datas,sizeof(char),size,file);
        }

        pour écrire ton "long" il suffit de faire

        write_long(FILE* file,long data){
        write_some_data(file,&data,sizeof(data));
        }

        c'est plus simple, non?

        Et tu peut faire pareil pour n'importe quel type de donné...un int, un short ...

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.