Je comprends le problème pour les structures (ça a été discuté dans fclc
il y a quelques temps). En revanche, ne connaissant pas C++, je me dis
qu'il doit y avoir une raison pour choisir un classe plutôt qu'une
structure.
Je comprends le problème pour les structures (ça a été discuté dans fclc
il y a quelques temps). En revanche, ne connaissant pas C++, je me dis
qu'il doit y avoir une raison pour choisir un classe plutôt qu'une
structure.
Je comprends le problème pour les structures (ça a été discuté dans fclc
il y a quelques temps). En revanche, ne connaissant pas C++, je me dis
qu'il doit y avoir une raison pour choisir un classe plutôt qu'une
structure.
Je comprends le problème pour les structures (ça a été discuté dans fclc
il y a quelques temps). En revanche, ne connaissant pas C++, je me dis
qu'il doit y avoir une raison pour choisir un classe plutôt qu'une
structure.
Benoit, je t'aime bien, mais dans ce cas-la precise que tu es un gros
debutant, ca evitera de rajouter du bruit...
Alors, voila. [...]
Je comprends le problème pour les structures (ça a été discuté dans fclc
il y a quelques temps). En revanche, ne connaissant pas C++, je me dis
qu'il doit y avoir une raison pour choisir un classe plutôt qu'une
structure.
Benoit, je t'aime bien, mais dans ce cas-la precise que tu es un gros
debutant, ca evitera de rajouter du bruit...
Alors, voila. [...]
Je comprends le problème pour les structures (ça a été discuté dans fclc
il y a quelques temps). En revanche, ne connaissant pas C++, je me dis
qu'il doit y avoir une raison pour choisir un classe plutôt qu'une
structure.
Benoit, je t'aime bien, mais dans ce cas-la precise que tu es un gros
debutant, ca evitera de rajouter du bruit...
Alors, voila. [...]
class A {
int un;
double deux;
}
Tu veux sûrement dire la taille des instances ? Je ne pense pas que ce
soit la taille en soi qui intéresse Lucas, mais plutôt la fragmentation
induite par l'ordre et l'alignement des champs.
class A {
int un;
double deux;
}
Tu veux sûrement dire la taille des instances ? Je ne pense pas que ce
soit la taille en soi qui intéresse Lucas, mais plutôt la fragmentation
induite par l'ordre et l'alignement des champs.
class A {
int un;
double deux;
}
Tu veux sûrement dire la taille des instances ? Je ne pense pas que ce
soit la taille en soi qui intéresse Lucas, mais plutôt la fragmentation
induite par l'ordre et l'alignement des champs.
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
Bonjour,
Le 08/10/2012 11:06, Lucas Levrel a écrit :class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionnera partout
(à vérifier tout de même), mais si toi ou quelqu'un d'autre se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Bonjour,
Le 08/10/2012 11:06, Lucas Levrel a écrit :
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionnera partout
(à vérifier tout de même), mais si toi ou quelqu'un d'autre se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Bonjour,
Le 08/10/2012 11:06, Lucas Levrel a écrit :class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionnera partout
(à vérifier tout de même), mais si toi ou quelqu'un d'autre se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
ptr = (double*)(((char*)ptr) + sizeof(A));C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Je suppose que sa fonction prend un déplacement et un pointeur vers
double. Lui faire comprendre qu'elle peut avoir des A nécessiterait soit de
la dupliquer pour tous les types possibles, soit en faire un template de
fonctions (ce est qui la meilleure solution en C++ pour l'interface, quite
à ce que l'implémentation du template fasse suivre à une f onction partagée
entre les instances si la duplication est réellement un problèm e).
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionner a partout
(à vérifier tout de même), mais si toi ou quelqu'un d'aut re se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Il me semble que ça a été dit, il n'est en rien garanti qu e sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je s erais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
ptr = (double*)(((char*)ptr) + sizeof(A));
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Je suppose que sa fonction prend un déplacement et un pointeur vers
double. Lui faire comprendre qu'elle peut avoir des A nécessiterait soit de
la dupliquer pour tous les types possibles, soit en faire un template de
fonctions (ce est qui la meilleure solution en C++ pour l'interface, quite
à ce que l'implémentation du template fasse suivre à une f onction partagée
entre les instances si la duplication est réellement un problèm e).
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionner a partout
(à vérifier tout de même), mais si toi ou quelqu'un d'aut re se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Il me semble que ça a été dit, il n'est en rien garanti qu e sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je s erais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
ptr = (double*)(((char*)ptr) + sizeof(A));C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Je suppose que sa fonction prend un déplacement et un pointeur vers
double. Lui faire comprendre qu'elle peut avoir des A nécessiterait soit de
la dupliquer pour tous les types possibles, soit en faire un template de
fonctions (ce est qui la meilleure solution en C++ pour l'interface, quite
à ce que l'implémentation du template fasse suivre à une f onction partagée
entre les instances si la duplication est réellement un problèm e).
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionner a partout
(à vérifier tout de même), mais si toi ou quelqu'un d'aut re se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Il me semble que ça a été dit, il n'est en rien garanti qu e sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je s erais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
Tant qu'à jouer à bas niveau, j'aurais tendance à faire
ptr = (double*)(((char*)ptr) + sizeof(A));
au moins je ne vois pas de problèmes (cast de et vers char* ne pose pas
de problème d'alias, ajouter sizeof(A) puis recaster en double* fonctionne
même si le ppcm de l'alignement d'un double et d'un int est plus petit que
la taille d'un double)
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Je suppose que sa fonction prend un déplacement et un pointeur vers
double.
Lui faire comprendre qu'elle peut avoir des A nécessiterait soit de
la dupliquer pour tous les types possibles, soit en faire un template de
fonctions (ce est qui la meilleure solution en C++ pour l'interface, quite
à ce que l'implémentation du template fasse suivre à une fonction partagée
entre les instances si la duplication est réellement un problème).
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionnera partout
(à vérifier tout de même), mais si toi ou quelqu'un d'autre se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
Tant qu'à jouer à bas niveau, j'aurais tendance à faire
ptr = (double*)(((char*)ptr) + sizeof(A));
au moins je ne vois pas de problèmes (cast de et vers char* ne pose pas
de problème d'alias, ajouter sizeof(A) puis recaster en double* fonctionne
même si le ppcm de l'alignement d'un double et d'un int est plus petit que
la taille d'un double)
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Je suppose que sa fonction prend un déplacement et un pointeur vers
double.
Lui faire comprendre qu'elle peut avoir des A nécessiterait soit de
la dupliquer pour tous les types possibles, soit en faire un template de
fonctions (ce est qui la meilleure solution en C++ pour l'interface, quite
à ce que l'implémentation du template fasse suivre à une fonction partagée
entre les instances si la duplication est réellement un problème).
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionnera partout
(à vérifier tout de même), mais si toi ou quelqu'un d'autre se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
class A {
int un;
double deux;
}
J'ai un tableau d'A :
A tab[1000];
et je veux en extraire un tableau d'A.deux. Donc je définis
double *ptr=&(tab->deux);
puis je fais une boucle qui incrémente
ptr += sizeof(A)/sizeof(double);
Tant qu'à jouer à bas niveau, j'aurais tendance à faire
ptr = (double*)(((char*)ptr) + sizeof(A));
au moins je ne vois pas de problèmes (cast de et vers char* ne pose pas
de problème d'alias, ajouter sizeof(A) puis recaster en double* fonctionne
même si le ppcm de l'alignement d'un double et d'un int est plus petit que
la taille d'un double)
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
Je suppose que sa fonction prend un déplacement et un pointeur vers
double.
Lui faire comprendre qu'elle peut avoir des A nécessiterait soit de
la dupliquer pour tous les types possibles, soit en faire un template de
fonctions (ce est qui la meilleure solution en C++ pour l'interface, quite
à ce que l'implémentation du template fasse suivre à une fonction partagée
entre les instances si la duplication est réellement un problème).
Plus précisément, je pense que ta technique doit fonctionner, peut-être
même la norme te donnera-t-elle l'assurance que ça fonctionnera partout
(à vérifier tout de même), mais si toi ou quelqu'un d'autre se trouve
devoir débuguer ce code dans quelques mois ou quelques années ça risque
d'être difficile à relire.
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
Ce qu'on a dit, c'est que sizeof(A) est un multiple entier du plus grand
des champs (parce que celui-ci doit être aligné, y compris dans un
tableau). Et le plus grand a l'air d'être un double.
Je ne connais pas
d'archi ou sizeof(double) < sizeof(int), mais pourquoi pas...
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
Ce qu'on a dit, c'est que sizeof(A) est un multiple entier du plus grand
des champs (parce que celui-ci doit être aligné, y compris dans un
tableau). Et le plus grand a l'air d'être un double.
Je ne connais pas
d'archi ou sizeof(double) < sizeof(int), mais pourquoi pas...
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
Ce qu'on a dit, c'est que sizeof(A) est un multiple entier du plus grand
des champs (parce que celui-ci doit être aligné, y compris dans un
tableau). Et le plus grand a l'air d'être un double.
Je ne connais pas
d'archi ou sizeof(double) < sizeof(int), mais pourquoi pas...
Le 08/10/2012 16:58, Alain Ketterlin a écrit :
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
Ce qu'on a dit, c'est que sizeof(A) est un multiple entier du plus grand
des champs (parce que celui-ci doit être aligné, y compris dan s un
tableau). Et le plus grand a l'air d'être un double.
Un multiple entier du plus grand des champs, ou un multiple entier du
plus grand des alignements requis ?
Je ne connais pas d'archi ou sizeof(double) < sizeof(int), mais
pourquoi pas...
;-)
Pourquoi pas, en effet, mais ce n'est pas là que serait le problà ¨me.
Il y aurait problème si on avait sizeof(int) = 4, sizeof(double) = 8,
mais alignement(int) = alignement(double) = 4. Dans ce cas, la taille
de A serait de 12 octets, et sizeof(A)/sizeof(double) vaudrait 3/2.
Le 08/10/2012 16:58, Alain Ketterlin a écrit :
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
Ce qu'on a dit, c'est que sizeof(A) est un multiple entier du plus grand
des champs (parce que celui-ci doit être aligné, y compris dan s un
tableau). Et le plus grand a l'air d'être un double.
Un multiple entier du plus grand des champs, ou un multiple entier du
plus grand des alignements requis ?
Je ne connais pas d'archi ou sizeof(double) < sizeof(int), mais
pourquoi pas...
;-)
Pourquoi pas, en effet, mais ce n'est pas là que serait le problà ¨me.
Il y aurait problème si on avait sizeof(int) = 4, sizeof(double) = 8,
mais alignement(int) = alignement(double) = 4. Dans ce cas, la taille
de A serait de 12 octets, et sizeof(A)/sizeof(double) vaudrait 3/2.
Le 08/10/2012 16:58, Alain Ketterlin a écrit :
Il me semble que ça a été dit, il n'est en rien garanti que sizeof(A) soit
un multiple entier de sizeof(double). (Un int de 4 bytes et un double
aligné sur 4 bytes ne me semble pas une absurdité, en fait je serais même
surpris qu'aucun compilateur n'ait jamais utilisé ce mode).
Ce qu'on a dit, c'est que sizeof(A) est un multiple entier du plus grand
des champs (parce que celui-ci doit être aligné, y compris dan s un
tableau). Et le plus grand a l'air d'être un double.
Un multiple entier du plus grand des champs, ou un multiple entier du
plus grand des alignements requis ?
Je ne connais pas d'archi ou sizeof(double) < sizeof(int), mais
pourquoi pas...
;-)
Pourquoi pas, en effet, mais ce n'est pas là que serait le problà ¨me.
Il y aurait problème si on avait sizeof(int) = 4, sizeof(double) = 8,
mais alignement(int) = alignement(double) = 4. Dans ce cas, la taille
de A serait de 12 octets, et sizeof(A)/sizeof(double) vaudrait 3/2.
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.
C'est un peu casse-gueule, tu ne crois pas ? Alors qu'il serait si
simple d'avoir un pointeur sur A, que tu incrémentes normalement,
avant d'en extraire le deux à chaque tour de boucle.