Lol ! C´est en Octet => voilà pourquoi je comprenais pas ! ( Dans mon livre ils mettent en bits, pourquoi ne pas avoir mis la taille des types en octet vu que c´est la grandeur qu´on utilise... arf).

Le tableau, j´ai fait
int machin[5];
cout < < sizeof(machin);

Mais avec ton explication précédente sur les octets, maintenant c´est bien plus clair ! En effet, un int est sur 16 bits ( 2 octets) -> ce qui fait 2*5 = 10
Encore merci !

ps : j´essaie le sizeof sur l´exemple de structure que tu as donné ce soir ; ). En théorie, un long étant sur 32 bits et un char sur 8, ça devrait bien faire 40 bits, soit 5 octets... Mais vu le ton de ta phrase, je m´attends à retrouver des surprises

Essaie, tu verras que ça ne te donne pas 5 octets.
Sinon, tu dis que tes int sont sous 16 bits ? ??

Quelle compilateur utilises tu ? ? ( les vieux compilos DOS étaient sous 16 bits ! apres, c´est passé a 32 ! !)

Euh... TC++ mais je savais pas que les compilos interprétaient un même type différemment

en fait, pour tous les types, c´est pareil de compilos en compilos, sauf le int :

avant ( a l´epoque du DOS) le int était sur 16 bits
maintenant sur 32.
TC++ est un vieuuuuux compilateur
mais hormis cela, tout est pareil que sur les nouveaux

ATTENTION SPOILER

• • ********************

le resultat de sizeof( S) pour S = char + long , je trouve 8
la question est pourquoi

normal essaie d´inverser les membres dans la structure now :

struct S
{
long t;
char s;
};

salut!

J´ai inversé les membres et je trouve toujours 8... ça devait faire quelque chose de spécial ?

Par contre j´ai un peu avancé dans la lecture du bouquin et j´en suis aux pointeurs ( par contre là je connais pas du tout).
Est-ce qu´ils servent principalement à manipuler une variable dans une autre fonction que dans celle où est initialisé le pointeur ?

Une autre embrouille dans ce bouquin : à quoi ça me sert de savoir qu´1 pointeur vers une variable d´un int long sera interprété comme un pointeur de type long et qu´il récupérera les 4 octets de la variable, pas seulement le 1er ?
Aussi, je voudrais dire que je comprends rien à cette phrase à rallonge -> si quelqu´un peut dire ça simplement je refuse pas .

Plus loin dans le chapitre des pointeurs je comprends pas non plus le fait que quand on ajoute par ex. 1 à 1 pointeur, il se déplace d´un nombre d´octects équivalent à celui correspondant au type de la variable pointée ? C´est un peu " chercher compliqué alors qu´on peut faire simple" non ?
Est-ce qu´il est nécessaire de comprendre ce charabia sur les adresses/octets ? Parce que bon si je me décourage devant ça je vais encore lâcher l´affaire plusieurs mois...

" Est-ce qu´ils servent principalement à manipuler une variable dans une autre fonction que dans celle où est initialisé le pointeur ? "
non, on s´en sert partout : agencement de donnees en memoire, polymorphisme, et bcp d´autres choses.

" à quoi ça me sert de savoir qu´1 pointeur vers une variable d´un int long sera interprété comme un pointeur de type long et qu´il récupérera les 4 octets de la variable, pas seulement le 1er ? "
ca veut dire que quand tu dereferences ton pointeur, il te renvoit TOUTE la donnee pointee ( ou objet) : la donnee pointee a donc une taille.
Ca veux aussi dire qu´en castant ton pointeur tu modifies les tailles des donnees interpretees quand tu dereferences ( i.e. caster un int * en char * et dereferencer te renverra seulement UN octer des 4 de l´int - a voir la norme, little/big endian pour l´octet renvoye - )

" quand on ajoute par ex. 1 à 1 pointeur, il se déplace d´un nombre d´octects équivalent à celui correspondant au type de la variable pointée ? C´est un peu chercher compliqué alors qu´on peut faire simple non ? "
non au contraire ; cette arithmetique des pointeurs est capitale quand tu les modifies ( pour te balader en memoire) : tu t´occupes pas de la taille de chaque donnee, tu incrementes, tu decrementes, et a chaque tu de deplaces de " 1 objet" entier. TRES pratique.

si tu veux avancer a la main d´un nb d´objets connu, tu peux toujours caster en char * :

object *p = &
p = reinterpret_cast<object *>(reinterpret_cast<char *>(p) + offset)

si tu sais pas EXACTEMENT ce que tu fais avec ce genre d´operation, c´est garanti de crasher ton appli.

" Est-ce qu´il est nécessaire de comprendre ce charabia sur les adresses/octets ? "
c´est le coeur meme ; c´est CAPITAL de comprendre ce qu´on fait ; mais au debut c´est normal de galerer, aussi...

" toute la donnee pointee" = toutes les cases mémoire qu´un type occupe ?
Je commence à entrevoir certaines de tes explications, mais c´est quand même assez technique en terme de vocabulaire. Bah, je verrai bien si au fil du temps si ça rentrera.

Non c´est bon je viens de piger que c´est pas ça la donnée pointée.
I´ll be back quand j´en serai au déréférencement. Pour l´instant, en lisant ça je me fais soufrance

Au fait, je peux avoir l´explication au fait que un long + char = 5 octets dans une structure ?

err... long + char = 8 octets

Aaaaah je crois que je viens de comprendre à quoi servaient les classes . ..
Avec une seule classe Pingouin, je peux créer deux pingouins possédant les memes caracteristiques ( position vie etc ) mais dans des proprotions pas forcément egales . ..
cool

jeanYvesYves,
en fait, l´idée éatit de développer un système d´exploitation. Toute façon, j´ai encore pas mal de chose à apprendre avant de pouvoir concrétiser ce projet. Mais à quoi bon apprendre sans but?

J´ai encore une question de sa part : comment intégrer des graphismes de blender dans un programme ?

également sans rapport véritable avec le C++... mais bon, on va répondre quand meme : blender étant un modeleur, je présume que c´est le modele 3D qui t´interesse. Il faut l´exporter dans un format que tu sais relire ( 3DS ? DXF ? X ? etc.), et exploiter ces informations dans ton programmes pour recreer la structure de l´objet 3D ( charger les vertices, calculer les normales, construire les listes de triangles, etc.) ; en gros ça revient à convertir les données utilisées par blender par des données qui representent la meme chose, mais dans ton programme. Ensuite seulement tu as le controle de ton objet 3D, et tu peux le rendre via une API 3D.

j´ai demandé la même chose sur programmation, mais je pose ma question ici aussi :

est ce que quelqu´un peut m´expliquer la différence entre ça :
Complexe operator+(Complexe &);
et ça :
Complexe &+(Complexe &);

le petit & de plus qui m´oblige à renvoyer un pointeur plutot qu´un objet.

je veux dire, je sais ce que ça veut dire, mais à l´exécution, est ce qu´il y en a un qui est meilleur que l´autre ou alors ça dépend des situations ?
merci d´avance pour vos réponses.

tu ne peux pas renvoyer un Complexe & sur operator + de manière satisfaisante. Pourquoi ? Parceque pour etre bien concu, operator + ne devrait pas modifier l´objet sur lequel il porte ; or s´il ne modifie pas this, tu ne renvoies donc pas *this, mais un nouveau Complexe : renvoyer un & d´un nouveau complexe qui est une variable LOCALE, c´est tres mal pas bien... A proscire.
Par contre sur operator += , pour qui il est logique de modifier this, il est fortement recommendé de renvoyé un const Complexe & , ce qui permet d´enchainer les opérations, sans écrire n´importe quoi, tout en évitant la construction inutile d´objets ( ce qui peut etre TRES couteux selon le type de tes objets)

Houlala je viens de télécharger le moteur Irrlicht , c du gros !
J´ai jamais vu ca , il sont prévus des tutoriaux pour dev-cpp qui marchent !
je compile le Hello World , et hop , un modele 3d dans une fenetre , alors que le code fait 30 lignes

( d´ailleurs , trop de commentaires tuent les commentaires . .. )

Bon , je dis que c´est incroyable , parceque j´avais deja telecharge des moteurs 3d ( Game incubator entre autres ) sans jamais reussir a rien compiler !

bon , préparez vous a repondre a plein de questions sur ca , ceux qui s´y connaissent ^^
ok j´irais d´abord voir sur les forums du site officiel