Bonjour,  
 
Je cherche à écrire un nombre (qui ne dépassera pas 255) dans un octet... Le type de codage le plus petit en C pour un nombre, c'est le "short" à ma connaissance, mais il prend 2 octets en mémoire...
 
Une idée ?

char
 
edit: notons qu'en C un char à toujours une longueur d'un byte, mais qu'un byte ne fait pas toujours un octet </pedantic>

Hum je viens de penser à quelque chose : sachant qu'un char est codé sur 1 octet (à confirmer tout de même), avec un memcpy ça passerait ?
 
Exemple :

Merci ça confirme donc mon idée  
 
EDIT : dans la majeure partie des cas c'est bien un octet ?

faudrait que je revois mon vocabulaire moi !!
 
octet n'est pas la traduction francaise de byte ??

char nombre;
nombre = 255;
 
?

taz va faire une attaque

 
si char fait bien 8 bits, tu vas l'avoir dans le cultre
 
unsigned char nombre = 255;
 
félicitation a Froozen au passage, jamais vu un code si compliqué (par ailleurs buggé)pour faire une pauvre assignation

J'aime bien ce forum, on se demande l'utilité de poser une question si c'est pour se faire démonter à chaque faute. Excusez-moi de vous avoir dérangés ô maitres de la programmation.
 
Par ailleurs j'ai eu ma réponse de manière beaucoup plus agréable sur un IRC, il suffisait donc de déclarer un unsigned char et d'y affecter directement ma valeur 255.
 
C'est pitoyable vraiment l'ambiance ici...

 
Je sais pas si t'as vu, 1) je t'ai fourni ta réponse 2) je t'ai pas insulté, 3) mon ton n'etait pas agressif
 
mais je suppose que ca fait du bien de raler plein pot

Il n'y a pas d'octet en C.
 
Un unsigned char est un entier comme les autres. Le langage C garantit qu'il peut recevoir les valeurs de 0 à 255. Il occupe un byte en mémoire soit au moins 8 bits.

Ta remarque t'aurais pu te la garder aussi...

Oui, mais c'est une façon compliquée d'écrire  

c'est toi qui vois...
 
Nota. Un char peut être signé ou non selon l'implémentation. Pour être sûr qu'il soit non signé (et donc qu'il accepte 255), j'ai utilisé unsigned char. Comme ça, c'est portable...

Ok  

 
tu t'es senti vexé ?

Non. En C, le byte (en français 'multiplet', quel vilain mot...) est l'unité d'adressage mémoire. Elle fait au moins 8 bits. Le C garanti qu'un char occupe exactement 1 byte en mémoire.

Oui Oui, je vais biensûr utiliser la deuxième forme, la première c'était juste pour le principe (je suis plongé dans les chaînes de caractères et les memcpy en ce moment, CQFD).
 
Merci pour les réponses.

En gros, tu as le droit de te plaindre et les autres celui de fermer leur gueule.. Belle mentalité. T'es sûr que tu veux de l'aide ?

 
pour info, quand meme, ton appel a memcpy est buggé
 

Tu l'as essayé pour dire ça ou t'as une explication à me donner ?

docteur es segfault a parlé

Dans ce cas précis (memcpy() attend un void*), les deux écritures sont équivallentes. Sticto sensu, l'une n'est pas meilleure que l'autre. En effet, bien que les types soient différents ('char (*)[1]' vs 'char *'), la valeur est la même. Mais par habitude, je préfère la seconde, même dans ce cas là.

 
"caractere" équivaut à "&caractere" ?
Je trouve ça étonnant ???
 
Moi j'aurais dit "caractere" equivaut à "&caractere[0]"
???

 
diantre, je mets ca sur le coup de la fatigue, soit de la mienne soit de la tienne, mais pour moi  
 
&caractere != (caractere == &caractere[0])
 

 
non tu penses bien que je suis juste la pour te pourrir l'ambiance et faire de sales remarques

oulà, j'ai bien fait de jouer à Warcraft tout le weekend

 
C'est parce que "caractere" est le nom d'un tableau donc la valeur présente dans la variable "caractere" correspond à l'adresse du premier élément du tableau.
Donc "caractere" équivaut à "&caractere[0]"
 
Donc soit tu passes à "memcpy" la valeur "caractere", soit tu lui passes la valeur "&caractere[0]"; tous deux sont des "char*". Mais tu ne lui passes surtout pas "&caractere" qui est l'adresse d'une adresse autrement dit un "char **"
 
Ou alors tu déclares "caractere" comme un "char" et non comme un  
"char[1]" (parce que déclarer un tableau d'un seul élément c'est pas trop utile) et tu peux écrire ton "memcpy" comme tu l'avais écrit (si tu tiens réellement à utiliser "memcpy" )

Je confirme. C'est la même valeur, mais pas le même type.

 
gcc:

C'est égal : même valeur, même type.

Exact. Même valeur, même type (adresse d'un char soit char *).

Non. Tu confonds tableau et pointeur. Dans l'expression  

'caractere' n'est pas un pointeur mais un tableau. &caractère est donc l'adresse d'un tableau de 1 caractère, et son type est char (*)[1] et non char** (ce serait le type de l'adresse d'un pointeur sur char). Je sais que beaucoup ont du mal à le croire, mais un tableau et un pointeur sont des choses différentes.
 
Les valeurs de 'caractere' et de &caractere sont identiques parce que la norme dit que le premier élément d'un tableau se situe à l'adresse de celui-ci, donc
 
caractere + 0 == &caractere[0]
 
mais les types sont differents, comme je l'ai démontré.
 
Ce sujet a été épuisé ad nauseam sur les forums de référence du C que sont news:comp.lang.c et news:fr.comp.lang.c (pour la partie francophone). Il est donc inutile de polémiquer. Il suffit de lire leurs archives, et notamment les contributions de Chris Torek ou Horst Kramer.
 
Je ne fais que synthétiser leur propos (mais c'est vrai que j'ai mis du temps à comprendre, comme tout soi-disant programmeur C... mal formé).

oué en fait si on se fait un pety dessin avec la stack frame alors c'est logique

Je demandais si tu l'avais simplement essayé ou si tu pouvais en plus m'expliquer pourquoi il y avait cette erreur    

 
bin vu comment tu reagis quand on te dis des trucs, ca me donne pas envie de me lancer dans de grandes explications

Sinon merci pour vos nombreuses réponses

Te fatigue pas va, d'autres l'ont fait à ta place.

 
Je suis en train de lire les FAQ http://www.isty-info.uvsq.fr/~rumeau/fclc. Et j'ai même vu ton nom dans la liste des contributions...  

on voit meme Emmanuel Delahaye figurer aux cotés de Gabriel Dos Reis

En général c'est pour me faire rotir...
 

c'est déjà une performance de pas se faire manger tout cru