Bonjour
J'aimerai savoir s'il existe des stratagèmes pour qu'une instance
constante d'une classe soit directement initialisée dans l'exécutable et
ne nécessite pas l'appel de constructeurs globaux.
Pour faire plus clair :
-->
class Biniou {
int a;
char b;
public :
const int get_a( void ) const { return a; };
const char get_b( void ) const { return b; };
int & set_a( void ) { return a; };
char & set_b( void ) { return b; };
};
// ligne invalide, mais qui veut bien dire ce qu'elle veut dire
const Biniou wesh = { 5, 'c' };
<--
La surcharge du constructeur amènerait à une initialisation dynamique et
non statique. Aujourd'hui j'en suis réduit à patcher la section 'data'
de l'exécutable pour réaliser mes initialisations, ce qui est efficace
mais peu propre...
Donc si l'un d'entre vous a une idée, elle est la bienvenue
PS: les initalisations peuvent être citiques dans le cas de programmes
temps-réel embarqués.
Un truc moins "ch**nt" que de patcher la section data serait peut-être :
Bonjour
J'aimerai savoir s'il existe des stratagèmes pour qu'une instance
constante d'une classe soit directement initialisée dans l'exécutable et
ne nécessite pas l'appel de constructeurs globaux.
Pour faire plus clair :
-->
class Biniou {
int a;
char b;
public :
const int get_a( void ) const { return a; };
const char get_b( void ) const { return b; };
int & set_a( void ) { return a; };
char & set_b( void ) { return b; };
};
// ligne invalide, mais qui veut bien dire ce qu'elle veut dire
const Biniou wesh = { 5, 'c' };
<--
La surcharge du constructeur amènerait à une initialisation dynamique et
non statique. Aujourd'hui j'en suis réduit à patcher la section 'data'
de l'exécutable pour réaliser mes initialisations, ce qui est efficace
mais peu propre...
Donc si l'un d'entre vous a une idée, elle est la bienvenue
PS: les initalisations peuvent être citiques dans le cas de programmes
temps-réel embarqués.
Un truc moins "ch**nt" que de patcher la section data serait peut-être :
Bonjour
J'aimerai savoir s'il existe des stratagèmes pour qu'une instance
constante d'une classe soit directement initialisée dans l'exécutable et
ne nécessite pas l'appel de constructeurs globaux.
Pour faire plus clair :
-->
class Biniou {
int a;
char b;
public :
const int get_a( void ) const { return a; };
const char get_b( void ) const { return b; };
int & set_a( void ) { return a; };
char & set_b( void ) { return b; };
};
// ligne invalide, mais qui veut bien dire ce qu'elle veut dire
const Biniou wesh = { 5, 'c' };
<--
La surcharge du constructeur amènerait à une initialisation dynamique et
non statique. Aujourd'hui j'en suis réduit à patcher la section 'data'
de l'exécutable pour réaliser mes initialisations, ce qui est efficace
mais peu propre...
Donc si l'un d'entre vous a une idée, elle est la bienvenue
PS: les initalisations peuvent être citiques dans le cas de programmes
temps-réel embarqués.
Un truc moins "ch**nt" que de patcher la section data serait peut-être :
La surcharge du constructeur amènerait à une initialisation dynamique et
non statique.
La surcharge du constructeur amènerait à une initialisation dynamique et
non statique.
La surcharge du constructeur amènerait à une initialisation dynamique et
non statique.
Guillaume LEMAÎTRE wrote:La surcharge du constructeur amènerait à une initialisation dynamique
et non statique.
Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
Guillaume LEMAÎTRE wrote:
La surcharge du constructeur amènerait à une initialisation dynamique
et non statique.
Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
Guillaume LEMAÎTRE wrote:La surcharge du constructeur amènerait à une initialisation dynamique
et non statique.
Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
Loïc Joly wrote:Guillaume LEMAÎTRE wrote:La surcharge du constructeur amènerait à une initialisation
dynamique et non statique.
Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
à supposer que l'on ait en plus :
-->
class Biniou {
// ...
Biniou( const int p_a, const char p_b ) : a( p_a ), b( p_b ) {};
// ...
};
// alors la ligne devient
const Biniou wesh = Biniou( 5, 'c' );
<--
cette déclaration provoquera avant l'entrée dans le main l'appel au
constructeur que l'on vient de surcharger qui se chargera
d'initialiser l'instance 'wesh'. C'est-à-dire du temps de perdu à
initialiser un objet dont on pouvait connaître par avance le contenu
!
An implementation is permitted to perform the initialization of an
object of namespace scope with static storage duration as a static
initialization even if such initialization is not required to be done
statically, provided that
the dynamic version of the
initialization does not change the value of any other object of
namespace scope with static storage duration prior to its
initialization, and
- the static version of the initialization
produces the same value in the initialized object as would be
produced by the dynamic initialization if all objects not required to
be initialized statically were initialized dynamically.
When an aggregate with static storage duration is initialized with a
braceenclosed initializerlist, if all the member initializer
expressions are constant expressions, and the aggregate is a POD
type, the initialization shall be done during the static phase of
initialization (3.6.2); otherwise, it is unspecified whether the
initialization of members with constant expressions takes place
during the static phase or during the dynamic phase of
initialization.
Loïc Joly wrote:
Guillaume LEMAÎTRE wrote:
La surcharge du constructeur amènerait à une initialisation
dynamique et non statique.
Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
à supposer que l'on ait en plus :
-->
class Biniou {
// ...
Biniou( const int p_a, const char p_b ) : a( p_a ), b( p_b ) {};
// ...
};
// alors la ligne devient
const Biniou wesh = Biniou( 5, 'c' );
<--
cette déclaration provoquera avant l'entrée dans le main l'appel au
constructeur que l'on vient de surcharger qui se chargera
d'initialiser l'instance 'wesh'. C'est-à-dire du temps de perdu à
initialiser un objet dont on pouvait connaître par avance le contenu
!
An implementation is permitted to perform the initialization of an
object of namespace scope with static storage duration as a static
initialization even if such initialization is not required to be done
statically, provided that
the dynamic version of the
initialization does not change the value of any other object of
namespace scope with static storage duration prior to its
initialization, and
- the static version of the initialization
produces the same value in the initialized object as would be
produced by the dynamic initialization if all objects not required to
be initialized statically were initialized dynamically.
When an aggregate with static storage duration is initialized with a
braceenclosed initializerlist, if all the member initializer
expressions are constant expressions, and the aggregate is a POD
type, the initialization shall be done during the static phase of
initialization (3.6.2); otherwise, it is unspecified whether the
initialization of members with constant expressions takes place
during the static phase or during the dynamic phase of
initialization.
Loïc Joly wrote:Guillaume LEMAÎTRE wrote:La surcharge du constructeur amènerait à une initialisation
dynamique et non statique.
Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
à supposer que l'on ait en plus :
-->
class Biniou {
// ...
Biniou( const int p_a, const char p_b ) : a( p_a ), b( p_b ) {};
// ...
};
// alors la ligne devient
const Biniou wesh = Biniou( 5, 'c' );
<--
cette déclaration provoquera avant l'entrée dans le main l'appel au
constructeur que l'on vient de surcharger qui se chargera
d'initialiser l'instance 'wesh'. C'est-à-dire du temps de perdu à
initialiser un objet dont on pouvait connaître par avance le contenu
!
An implementation is permitted to perform the initialization of an
object of namespace scope with static storage duration as a static
initialization even if such initialization is not required to be done
statically, provided that
the dynamic version of the
initialization does not change the value of any other object of
namespace scope with static storage duration prior to its
initialization, and
- the static version of the initialization
produces the same value in the initialized object as would be
produced by the dynamic initialization if all objects not required to
be initialized statically were initialized dynamically.
When an aggregate with static storage duration is initialized with a
braceenclosed initializerlist, if all the member initializer
expressions are constant expressions, and the aggregate is a POD
type, the initialization shall be done during the static phase of
initialization (3.6.2); otherwise, it is unspecified whether the
initialization of members with constant expressions takes place
during the static phase or during the dynamic phase of
initialization.
Ah, je crois voir enfin ce que tu entendais par dynamique (j'avais
confondu avec le dynamique de à new ou malloc).
Si c'est bien le cas, je me pose alors quelques questions :
- Est-ce important ? Je n'ai pas l'impression que le temps
d'initialisation de quelques constantes soit en général un problème en
terme de performances.
- Un bon compilateur n'aurait-il pas le droit d'initialiser l'objet wesh
à la compilation ? Voire même de supprimer toute référence à wesh du
programme final et de remplacer tous les wesh.get_a() par 5 (puis de
continuer éventuellement à optimiser). Je n'ai rien vu dans la norme qui
semble empêcher ça (mais si je commence à savoir m'y retrouver pour voir
si quelquechose existe, je suis encore loin de la connaître assez pour
savoir qu'une chose n'existe pas), mais est-ce à la portée des
compilateurs actuels.
En particulier (3.6.2.2) :
[snip]
Ah, je crois voir enfin ce que tu entendais par dynamique (j'avais
confondu avec le dynamique de à new ou malloc).
Si c'est bien le cas, je me pose alors quelques questions :
- Est-ce important ? Je n'ai pas l'impression que le temps
d'initialisation de quelques constantes soit en général un problème en
terme de performances.
- Un bon compilateur n'aurait-il pas le droit d'initialiser l'objet wesh
à la compilation ? Voire même de supprimer toute référence à wesh du
programme final et de remplacer tous les wesh.get_a() par 5 (puis de
continuer éventuellement à optimiser). Je n'ai rien vu dans la norme qui
semble empêcher ça (mais si je commence à savoir m'y retrouver pour voir
si quelquechose existe, je suis encore loin de la connaître assez pour
savoir qu'une chose n'existe pas), mais est-ce à la portée des
compilateurs actuels.
En particulier (3.6.2.2) :
[snip]
Ah, je crois voir enfin ce que tu entendais par dynamique (j'avais
confondu avec le dynamique de à new ou malloc).
Si c'est bien le cas, je me pose alors quelques questions :
- Est-ce important ? Je n'ai pas l'impression que le temps
d'initialisation de quelques constantes soit en général un problème en
terme de performances.
- Un bon compilateur n'aurait-il pas le droit d'initialiser l'objet wesh
à la compilation ? Voire même de supprimer toute référence à wesh du
programme final et de remplacer tous les wesh.get_a() par 5 (puis de
continuer éventuellement à optimiser). Je n'ai rien vu dans la norme qui
semble empêcher ça (mais si je commence à savoir m'y retrouver pour voir
si quelquechose existe, je suis encore loin de la connaître assez pour
savoir qu'une chose n'existe pas), mais est-ce à la portée des
compilateurs actuels.
En particulier (3.6.2.2) :
[snip]
En tout cas, merci d'avoir pris mon cas en considération !
En tout cas, merci d'avoir pris mon cas en considération !
En tout cas, merci d'avoir pris mon cas en considération !
J'aimerai savoir s'il existe des stratagèmes pour qu'une instance
constante d'une classe soit directement initialisée dans l'exécutable
et ne nécessite pas l'appel de constructeurs globaux.
Pour faire plus clair :
-->
class Biniou {
int a;
char b;
public :
const int get_a( void ) const { return a; };
const char get_b( void ) const { return b; };
int & set_a( void ) { return a; };
char & set_b( void ) { return b; };
};
// ligne invalide, mais qui veut bien dire ce qu'elle veut dire
const Biniou wesh = { 5, 'c' };
<--
La surcharge du constructeur amènerait à une initialisation dynamique
et non statique.
Aujourd'hui j'en suis réduit à patcher la section 'data' de
l'exécutable pour réaliser mes initialisations, ce qui est efficace
mais peu propre... Donc si l'un d'entre vous a une idée, elle est la
bienvenue
PS: les initalisations peuvent être citiques dans le cas de programmes
temps-réel embarqués.
J'aimerai savoir s'il existe des stratagèmes pour qu'une instance
constante d'une classe soit directement initialisée dans l'exécutable
et ne nécessite pas l'appel de constructeurs globaux.
Pour faire plus clair :
-->
class Biniou {
int a;
char b;
public :
const int get_a( void ) const { return a; };
const char get_b( void ) const { return b; };
int & set_a( void ) { return a; };
char & set_b( void ) { return b; };
};
// ligne invalide, mais qui veut bien dire ce qu'elle veut dire
const Biniou wesh = { 5, 'c' };
<--
La surcharge du constructeur amènerait à une initialisation dynamique
et non statique.
Aujourd'hui j'en suis réduit à patcher la section 'data' de
l'exécutable pour réaliser mes initialisations, ce qui est efficace
mais peu propre... Donc si l'un d'entre vous a une idée, elle est la
bienvenue
PS: les initalisations peuvent être citiques dans le cas de programmes
temps-réel embarqués.
J'aimerai savoir s'il existe des stratagèmes pour qu'une instance
constante d'une classe soit directement initialisée dans l'exécutable
et ne nécessite pas l'appel de constructeurs globaux.
Pour faire plus clair :
-->
class Biniou {
int a;
char b;
public :
const int get_a( void ) const { return a; };
const char get_b( void ) const { return b; };
int & set_a( void ) { return a; };
char & set_b( void ) { return b; };
};
// ligne invalide, mais qui veut bien dire ce qu'elle veut dire
const Biniou wesh = { 5, 'c' };
<--
La surcharge du constructeur amènerait à une initialisation dynamique
et non statique.
Aujourd'hui j'en suis réduit à patcher la section 'data' de
l'exécutable pour réaliser mes initialisations, ce qui est efficace
mais peu propre... Donc si l'un d'entre vous a une idée, elle est la
bienvenue
PS: les initalisations peuvent être citiques dans le cas de programmes
temps-réel embarqués.
Guillaume LEMAÎTRE writes:
| Loïc Joly wrote:
| > Guillaume LEMAÎTRE wrote:
| >> La surcharge du constructeur amènerait à une initialisation
| >> dynamique et non statique.
| > Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
| à supposer que l'on ait en plus :
| -->
| class Biniou {
| // ...
| Biniou( const int p_a, const char p_b ) :
| a( p_a ),
| b( p_b )
| {};
| // ...
| };
| // alors la ligne devient
| const Biniou wesh = Biniou( 5, 'c' );
| <--
| cette déclaration provoquera avant l'entrée dans le main l'appel au
| constructeur que l'on vient de surcharger qui se chargera
| d'initialiser l'instance 'wesh'. C'est-à-dire du temps de perdu à
| initialiser un objet dont on pouvait connaître par avance le contenu !
si tu arrives à mesurer le temps « perdu » à initialiser 'wesh' alors
c'est que ton programme ne fait rien d'intéressant ou il faut que tu
changes de compilateur.
Guillaume LEMAÎTRE <zarmalala@biniou.org> writes:
| Loïc Joly wrote:
| > Guillaume LEMAÎTRE wrote:
| >> La surcharge du constructeur amènerait à une initialisation
| >> dynamique et non statique.
| > Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
| à supposer que l'on ait en plus :
| -->
| class Biniou {
| // ...
| Biniou( const int p_a, const char p_b ) :
| a( p_a ),
| b( p_b )
| {};
| // ...
| };
| // alors la ligne devient
| const Biniou wesh = Biniou( 5, 'c' );
| <--
| cette déclaration provoquera avant l'entrée dans le main l'appel au
| constructeur que l'on vient de surcharger qui se chargera
| d'initialiser l'instance 'wesh'. C'est-à-dire du temps de perdu à
| initialiser un objet dont on pouvait connaître par avance le contenu !
si tu arrives à mesurer le temps « perdu » à initialiser 'wesh' alors
c'est que ton programme ne fait rien d'intéressant ou il faut que tu
changes de compilateur.
Guillaume LEMAÎTRE writes:
| Loïc Joly wrote:
| > Guillaume LEMAÎTRE wrote:
| >> La surcharge du constructeur amènerait à une initialisation
| >> dynamique et non statique.
| > Je ne vois pas pourquoi. Peux-tu expliciter ce que tu veux dire ?
| à supposer que l'on ait en plus :
| -->
| class Biniou {
| // ...
| Biniou( const int p_a, const char p_b ) :
| a( p_a ),
| b( p_b )
| {};
| // ...
| };
| // alors la ligne devient
| const Biniou wesh = Biniou( 5, 'c' );
| <--
| cette déclaration provoquera avant l'entrée dans le main l'appel au
| constructeur que l'on vient de surcharger qui se chargera
| d'initialiser l'instance 'wesh'. C'est-à-dire du temps de perdu à
| initialiser un objet dont on pouvait connaître par avance le contenu !
si tu arrives à mesurer le temps « perdu » à initialiser 'wesh' alors
c'est que ton programme ne fait rien d'intéressant ou il faut que tu
changes de compilateur.
