Bonjour,
    je viens solliciter votre aide à propos de deux progammes en C pour lesquels les questions suivantes me sont posées:
en supposant une architecture 32 bits, ce code est-il portable ?
fonctionne-t-il ? si oui que donne-t-il en sortie ?
 
Voici les deux codes:
1/
#include <stdio.h>
int main(void)
 {
         char toto[5]="12345";
         long *x;
         x=(long *) toto;
         printf("=> %lX\n", *x);
         x=(long *) (toto+1);
         printf("=> %lX\n", *x);
         return 0;
 }
 
2/
int main(void)
{
        char toto[256];
        long x=0x31323334;
        memcpy(toto, (char *) &x, sizeof(x));
        toto[4]='\0';
        printf("=> %s\n", toto);
        return 0;
}
 
Je vous remercie d'avance pour votre aide précieuse

C'est un devoir que tu veux nous faire faire...
 
Juste des indices :  
dans quel ordre range-t-on le octets
et mefie toit des seg-faults...

eh bien pour tout dire ce n'est pas un devoir, mais un questionnaire auxquel je dois répondre pour trouver un job...

mais merci pour les indices!

char toto[5]="12345";  
 
boum ....
 
memcpy(toto, (char *) &x, sizeof(x));
 
cast inutile,
sizeof x et non pas sizeof(x)
 
sinon ce n'est absolument pas portables

Taz, juste par curiosité, tu peux me dire pourquoi
"sizeof x et non pas sizeof(x)" ?
 

Merci TAZ,
je vais essayer d'interpréter ton "boum".
Pour quelle raison ces codes ne sont pas portables?

pour lever une ambiguité
la notation parenthésée est nécessaire pour distinguer un nom de type d'une variable
 
alors autant ne pas s'embrouiller  ... j'en entends déjà dire que sans parenthèse ça fait pas propre ... mais sizeof est un opérateur, pas une fonction.
 
surtout que tu peux avoir une variable avec le meme identificateur qu'un type

bin ca devrait tourner sur les architectures 32 bits je crois, par contre les résultats affichés dépendent de l'endian de la machine ...

non. problème d'alignement, problème de boutisme.
 
le résultat dépend de l'architecture ? donc non portable. le fait de pouvoir être compilé et exécuté sans dégat apparent ne prouve pas que quelque chose est portable.

oui, la portabilité est que sur toutes les architectures les résultats soit les mêmes, ce qui sera pas le cas.
 
le boutisme = endian en anglais je crois ?
 
sinon pour l'alignement, je vois pas réellement le pb ?
un alignement de 4 veut dire par exemple que la :
char toto[5]="12345";
chaque char sera mis tous les 4 octets en mémoire ?

lis les voyages de gulliver en français

Non pas boum, le 0 final de l'initialiseur est ignoré. Ca ferait boum si toto était utilisé plus loin dans un contexte où on attend une chaine de caractères, mais ce n'est pas le cas.

si ça fait boom. tu as une chaine invalide. le contexte induit une sémantique textuelle. c'est une erreur en C++ d'ailleurs. pour lever toute ambiguité, utiliser {1, 2, 3, 4, 5}

Non en C c'est correct, en C++ je ne sais pas mais ce n'est pas la question :-). Exemple tiré directement du standard C99:

(6.7.8.32)
 
(ajouté): bien sûr ici toto est initialisé avec {'1','2','3','4','5'} et non {1,2,3,4,5}...

mais j'amais di le contraire ... je diste juste que c'est une pratique à risque qui aurait du être banni

ah ben par 'boom' je pensais que tu disais qu'il y avait une erreur dans le code

char toto[5]="12345";  
printf(toto);
 
Ca fait boom.
 
=> char toto[6]="12345";

Evidemment, d'ou ce que j'ai écrit : "Ca ferait boum si toto était utilisé plus loin dans un contexte où on attend une chaine de caractères, mais ce n'est pas le cas."