T est un pointeur et un pointeur n'est jamais qu'une variable num�rique enti�re (g�n�ralement) non sign�e dont la taille est au minimum suffisante pour repr�senter l'ensemble des adresses m�moire accessibles sur le syst�me.
Et cette taille est clairement connue � la compilation!
On se fout pas mal de savoir que l'adresse m�moire obtenue donne acc�s � 5, 10 ou 10000 �l�ments parce que chacun de ces �l�ment est accessible � une adresse m�moire qui lui est propre et que le processeur est tout � fait en mesure de calculer sur la base de l'adresse du premier �l�ment, de la taille des �l�ments et de l'indice de l'�l�ment auquel on veut acc�der.
il y a au maximum trois inconnues au moment de la compilation:
Mais cela ne pose strictement aucun probl�me: on sait que nous obtiendrons de toutes mani�re une valeur num�rique enti�re non sign�e (dont la taille est parfaitement connue) correspondant � l'adresse � laquelle nous trouverons un espace contigu suffisant pour repr�senter l'ensemble des (to) �l�ments pour lesquels on a demand� de r�server de la m�moire.
- L'adresse � laquelle se trouvera le premier �l�ment
- le nombre d'�l�ment pour lequel l'allocation dynamique demandera de r�server de la m�moire
- l'indice de l'�l�ment auquel on essayera d'acc�der par la suite
Et nous avons la certitude que, le compilateur sachant parfaitement la taille que repr�sente un �l�ment en m�moire, il nous permettra d'acc�der � l'ensemble des adresses m�moires auxquelles se trouve le premier byte de chaque �l�ment.
Apr�s, il peut y avoir certains probl�me:
- Le syst�me peut ne pas trouver assez d'espace libre pour r�server l'espace pour le nombre d'�l�ments demand� : new va alors lancer une exception de type std::bad_alloc (ou, si on utilise la version nothrow, renvoyer l'adresse correspondant � NULL / nullptr (c++11) pour indiquer que ce n'est pas une adresse valide)
- en ayant demand� d'allouer (to) �l�ments, on peut essayer d'acc�der � l'�l�ment (to)+1 dont l'adresse m�moire peut contenir strictement tout et n'importe quoi. Mais �a, c'est un probl�me de logique, et ca n'a rien � voir avec l'alignement des donn�es
- d'autres probl�mes similaires que j'oublie peut �tre
L'int�r�t est tout simple : une classe utilise des donn�es pour fournir les services que l'on en attend.sur une classe, en expliquant l'int�r�t. Parce que j'ai beau chercher, je n'en trouve pas.
A ce titre, il faut que le processeur soit en mesure d'acc�der � ces donn�es, au m�me titre qu'il doit pouvoir acc�der aux diff�rents champs d'une structure ou � n'importe quelle variable de n'importe quel type.
Seulement, si la donn�e en question ne se trouve pas dans un des accumulateur du processeur (et bien qu'il y ai de plus en plus d'accumulateurs, il n'y en a pas un nombre extensible � l'infini), il va devoir aller la chercher "quelque part".
Ce "quelque part", correspond � la m�moire: soit une m�moire interne au processeur que l'on appelle "la pile", soit la m�moire g�n�rale du syst�me qu'on appelle "le tas".
Pour pouvoir trouver "la donn�e qui l'int�resse", il a donc besoin de savoir "o� elle se trouve" en m�moire.
Le seul moyen qu'il ait de savoir o� la donn�es se trouve passe... par l'adresse m�moire de l'�l�ment en question.
Et cette adresse doit etre accessible au compilateur.
Or, si les accumulateurs sont en mesure de contenir 32 ou 64 bits de donn�es, les adresses accessibles sont toutes s�par�es par 32 ou 64 bits de donn�es.
Le processeur ne peut acc�der au "subdivision" de ces 32 (ou 64) bits qu'une fois que ces 32 (ou 64) bits sont charg�s dans un accumulateur (parce que l'accumulateur est, lui-m�me subdivis� en diff�rentes parties de 8, 16 et �ventuellement 32 bits))
si tu ne pr�cise rien et que tu cr�es une structure proche de
le processeur chercher l'adresse � laquelle commence la structure et qui correspondra � l'adresse de c.
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4 struct MyStruct{ char c; int i; };
pour que le processeur puisse acc�der � i, il devra prendre l'adresse (accessible!) qui suit l'adresse de c et, au final, alors qu'un char a une taille de 1 et qu'il aurait donc suffit de 5 bytes pour repr�senter les deux donn�es, tu te retrouves avec un strcuture ayant une taille de 8, "simplement" parce que le compilateur a rajout� la taille de 3 char 'de bourrage" afin de placer i � une distance qui permette au compilateur d'y acc�der.
Ca, c'est ce qu'on appelle l'alignement.
Maintenant, que ce soit une structure ou une classe ne changera rien parce que le processeur devra toujours, � un moment ou � un autre, �tre en mesure d'acc�der aussi bien � i qu'� c.
Il ne faut pas chercher un int�r�t quelconque � cela, il faut y voir une obligation propre au style de fonctionnement du processeur!
C'est parce que le processeur a un mode de fonctionnement qui lui emp�che d'acc�der "facilement" � des donn�es qui ne sont pas s�par�es par 32 (ou 64) bits que le compilateur s'arrange pour que chaque donn�e de type diff�rent se retrouve � une adresse qui sera accessible par le processeur!
Mais, pardon, tu demandes quel serait l'int�r�t de modifier la mani�re dont les donn�es d'une classe seraient align�es
Ce serait exactement le m�me que celui que tu aurais � modifier la mani�re dont les donn�es d'une structure sont align�es : "grignoter" quelque bytes en espace m�moire n�cessaire.
Je n'y ai personnellement jamais eu recours, mais comme on peut parfaitement utiliser C++ en embarqu� et / ou pour programmer des eeprom et/ou des syst�mes o� le moindre byte de m�moire est important, les occasions de modifier la mani�re dont les donn�es d'une classe sont align�e sont au moins aussi nombreuses que celle de le faire en C sur pour les structures.
Par contre, l'int�r�t de le faire avec des donn�es priv�es est, bien sur, d'en faciliter l'encapsulation
Sauf que la norme est la seule chose qui te permette d'obtenir un r�sultat pour lequel tu puisse esp�rer une portabilit� totale.Certes il y a la norme C++, et il y a aussi l'utilisation de cette norme.
Le fait de jouer avec la mani�re dont les donn�es sont align�es te fais prendre de tr�s gros risques � ce niveauNuance: les d�veloppeurs C utilisent que l'alignement de structures. Les pauvres, il n'ont pas d'autre choixLes d�veloppeurs n'utilisent que l'alignement de structures (jusqu'� ce que vous me prouviez le contraire, bien s�r). Cela devient comme une norme implicite.
Les d�veloppeurs C++ peuvent parfaitement (pour des raisons qui leur sont propres, entre autre de m�moire disponible) utiliser l'alignement sur des classes.
Et, surtout, les d�veloppeur C++ qui ont le choix utiliseront l'alignement "par d�faut" des donn�es
Non!!! on peut le faire sur tout, m�me sur une union si tu le souhaites!On aligne des structures, et non pas des classes. Et c'est bien une diff�rence d'utilisation entre une classe et une structure en C++. Seule chose que j'ai voulu souligner.
Ce n'est pas parce qu'il n'est pas courent de le faire (qu'il s'agisse d'une classe ou d'une structure, je n'ai personnellement jamais �prouv� le besoin de "jouer" avec l'alignement des donn�es... et je suis sur que beaucoup de d�veloppeurs C++ qui ne travaillent pas dans l'embarqu� sont dans mon cas
) que cela ne se fait pas.
C'est "simplement" que le besoin est souvent "moins pr�sent"![]()
Mais c'est une erreur de taille!!!PS: j'ai dit qu'on ne pouvait pas aligner des classes, c'�tatit une erreur en effet, mais que j'ai corrig� lorsque j'ai donn� le code qui compile un alignement de classe. Cela ne change pas le raisonnement qu'on utilise des structures pour l'alignement.
Parce que tu avais commenc� par dire qu'on ne pouvait pas aligner une classe, ce qui est faux.
Et, en plus, tu pr�sentais cela comme une diff�rence entre les classes et les structures.
Mais comme ton assertion (on ne peut pas aligner des classes) �tait fausse, on peut difficilement dire qu'il s'agisse d'une diff�rence entre les deux
Du coup, on en revient strictement � la norme : la seule diff�rence qui existe entre une classe et une structure en C++, c'est l'accessibilit� par d�faut qui est appliqu�e par le compilateur![]()
Partager