Bon je ne sais pas si il y a bien des gens au courant de ça, mais il y a peu longtemps, j'ai réalisé que même les variables de bases sont des types définis par le compilateur et que une fois compilé, c'est l'exécutable lui-même qui vérifie les erreurs de types. Par exemple si on essaye de mettre un long dans un int, etc. Et que le comportement des erreurs, comme par exemple en java si on dépasse la capacité il ne fera pas un overflow mais plutôt il va recommencer "à l'envers" je veux dire quand il arrive avec un int de 2 octets à 65536 il recommence à -256 au lieu de planter ou un truc du genre, alors qu'en C c'est différent. Donc j'en ait conclu que lorsqu'on compile notre exe n'est pas exclusivement notre programme, mais il y a des routines de gestion du code d'inclus, etc. Alors au final une variable n'est qu'une adresse mémoire (ça je le savais déjà) mais qui est géré par des routines inclus à notre insu dans nos exe.  
 
Est-ce qu'il y a autre chose qui est inclus à part cela ?  
 
De plus, en asm, en code binaire pur, il n'y a donc aucune gestion ? Donc il n'y a qu'un seul type de variable, c'est-à-dire ce qu'on en fait ? Si je décides de mettre le nombre 4574 en mémoire, c'est à moi de gérer l'espace nécessaire ou si c'est le cpu qui s'en charge ?  
 
Car en asm, comment s'assurer que la mémoire est libre ou non ?  

Nulldragon, j'ai l'impression que tu mélanges tout.
 
En C comme en assembleur il n'y a aucun contrôle sur les types de base : si tu déclares un nombre et que tu fais n'importe quoi avec, personne ne viendra te dire que tu as dépassé les capacités de stockage du nombre : simplement ton programme aura un comportement bizarre. Dans ces langages, ton exécutable ne vérifie rien mais laisse le processeur travailler.
En assembleur, les différents types de données ne sont pas qu'un jeu d'écriture pour le programmeur : certaines instructions n'existant pas, il faut bien qu'à la compilation on te prévienne que certaines manipulations sont impossibles (du genre mov bl,eax).
 
Pour Java, j'en sais rien.
 
Quand tu crées un exe il y a beaucoup de choses qui sont ajoutées à ton code sans que tu le demandes. Par exemple tout le bazard nécessaire au chargement de ton code en mémoire, ou encore les librairies d'accès à la console ou de gestion de l'interface graphique.
 

Bonjour
Lors de l'édition de lien d'un programme, il y a des tas de choses qui sont rajoutées et pas à notre insu mais en connaissance de cause sinon lire des livres sur ce que fait une édition de lien.
La mémoire est disponible en totalité pour l'assembleur mais il vaut mieux demander au système d'exploitation l'autorisation de la modifier avant sans quoi on s'expose à des problèmes.
Il est possible de faire un code pur assembleur sans rajout sous linux en faisant une édition de lien avec l'option -nostdlib mais il faudra tout de même appeler quelques routines du sytème d'exploitation avec des int si on veut voir quelques choses se passer.

Salut,

Tu pourrais préciser ce que t'entends par là ?
Tu veux dire qu'il y a moyen de manipuler directement une donnée en connaissant son adresse réelle dans la mémoire physique ? Normalement, il me semble que n'importe quel OS qui fait de la pagination crée un espace d'adressage virtuel pour chaque processus en cours d'éxéxution nan ?
 
NullDragon : en effet, dans un programme C compilé ou un programme ASM assemblé, il n'y a aucune vérification lorsque tu fais des opérations sur une variable. Le fait de passer de 32767 à -32768 en incrémentant est une caractéristique physique de l'unité arithmétique et logique de ton processeur (il faut des langages interprétés par une machine de plus haut niveau pour que des Infinity et NaN puissent apparaîtrent, comme en java).

Bonjour
Quand on est en mode superviseur, il est toujours possible de créer un espace mémoire dans la GDT faisant 4 Go accessible en écriture et de charger le segment correspondant dans DS puis d'écrire ensuite ou on veut. C'est un moyen assez efficace de planter le système. Il est plus prudent de demander au système de créer un descripteur pour nous, ce qui évite d'écrire dans des zones mémoires sensibles.
Connaitre l'adresse physique en mémoire est difficile sur un système paginant la mémoire et est d'un intéret assez limité.
Un des grands intéret de l'assembleur c'est que justement les données n'ont aucun type prédéfini et il appartient au programmeur de savoir comment il considère les suites d'octets.
La remarque "passer de 32767 à -32768 en incrémentant"  présuppose que l'on considère que deux octets juxtaposés représentent un entier signé sur 16 bits. On aurait tout aussi bien pu considérer que cela représentait 2 caractères ascii ou un entier non signé ou ce que l'on veut. Cela a des aspect très pratique mais demande une grande rigueur dans la programmation.