Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
J'ai essaye
struct A {}
et
struct A {int :0;}
mais dans les deux cas j'ai un warning avec gcc (et je ne sais pas
comment le desactiver). Y aurait il une astuce sur le marche pour
eviter ca?
Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
J'ai essaye
struct A {}
et
struct A {int :0;}
mais dans les deux cas j'ai un warning avec gcc (et je ne sais pas
comment le desactiver). Y aurait il une astuce sur le marche pour
eviter ca?
Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
J'ai essaye
struct A {}
et
struct A {int :0;}
mais dans les deux cas j'ai un warning avec gcc (et je ne sais pas
comment le desactiver). Y aurait il une astuce sur le marche pour
eviter ca?
Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
J'ai essaye
struct A {}
et
struct A {int :0;}
mais dans les deux cas j'ai un warning avec gcc (et je ne sais pas
comment le desactiver). Y aurait il une astuce sur le marche pour
eviter ca?
On peut mettre un champ vide dans la structure:
Laurent Deniau <laurent.deniau@cern.ch> writes:
Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
J'ai essaye
struct A {}
et
struct A {int :0;}
mais dans les deux cas j'ai un warning avec gcc (et je ne sais pas
comment le desactiver). Y aurait il une astuce sur le marche pour
eviter ca?
On peut mettre un champ vide dans la structure:
Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
J'ai essaye
struct A {}
et
struct A {int :0;}
mais dans les deux cas j'ai un warning avec gcc (et je ne sais pas
comment le desactiver). Y aurait il une astuce sur le marche pour
eviter ca?
On peut mettre un champ vide dans la structure:
Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Pascal Bourguignon <pjb@informatimago.com> writes:
Laurent Deniau <laurent.deniau@cern.ch> writes:
Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Jean-Marc Bourguet wrote:Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Jean-Marc Bourguet wrote:
Pascal Bourguignon <pjb@informatimago.com> writes:
Laurent Deniau <laurent.deniau@cern.ch> writes:
Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Jean-Marc Bourguet wrote:Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Laurent Deniau writes:Jean-Marc Bourguet wrote:Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Et où mets tu le pointeur vers la classe?
(Pour moi, un système OO où les classes ne sont pas des objets (de
première classe!), ne vaut pas grand chose, mais c'est un avis
personnel).
Laurent Deniau <laurent.deniau@cern.ch> writes:
Jean-Marc Bourguet wrote:
Pascal Bourguignon <pjb@informatimago.com> writes:
Laurent Deniau <laurent.deniau@cern.ch> writes:
Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Et où mets tu le pointeur vers la classe?
(Pour moi, un système OO où les classes ne sont pas des objets (de
première classe!), ne vaut pas grand chose, mais c'est un avis
personnel).
Laurent Deniau writes:Jean-Marc Bourguet wrote:Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Et où mets tu le pointeur vers la classe?
(Pour moi, un système OO où les classes ne sont pas des objets (de
première classe!), ne vaut pas grand chose, mais c'est un avis
personnel).
Pascal Bourguignon wrote:Laurent Deniau writes:Jean-Marc Bourguet wrote:Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Et où mets tu le pointeur vers la classe?
Ce n'est pas un pointeur, mais un id qui joue le meme role. Ci-dessus
il est dans "object members", c'est a dire les membres de Object.(Pour moi, un système OO où les classes ne sont pas des objets (de
première classe!), ne vaut pas grand chose, mais c'est un avis
personnel).
Il se trouve que les classes sont des objets (de premiere classes).
Voici une partie de la hierarchie actuelle extraite des headers (a
lire avec fonte fixe!)
a+, ld.
COS classes, meta classes and property meta classes core hierarchy
follows the principle of 'uniform object oriented programming'
(e.g. everything-is-object) using the 'safe metaclass compatibility
model':
1) Behaviors are objects
2) Classes and generics are behaviors
3) Meta classes are classes
4) Property classes are meta classes
NIL
<- Nil (root/subclass of all class)
<- Any (root class of atoms)
<- TrueFalse (class)
<- True (class)
<- False (class)
<- Object (root class of instances)
[...]
Class
^
|
o---------o
NIL +---------->| cObject |==========#
^ | o---------o v
| | ^ v
o--------o o---------o | v
| Object |=========>| pObject |===========|===========# v
o--------o o---------o | v v
^ o-----------o v v
| +--------->| cBehavior |=====v==>v
| | o-----------o v v
| | ^ v v
o----------o o-----------o | v v
| Behavior |=======>| pBehavior |==========|==========>v v
o----------o o-----------o | v v
^ o--------o v v
| +---------->| cClass |=======v==>v
| | o--------o v v
| | ^ v v
o-------o o--------o | v v
| Class |==========>| pClass |============|==========>v v
o-------o o--------o | v v
^ o------------o v v
| +-------->| cMetaClass |=====v==>v
| | o------------o v v
| | ^ v v
o-----------o o------------o | v v
#=======>| MetaClass |=======>| pMetaClass |=========|==========>v v
^ o-----------o o------------o | v v
^ ^ o----------------o v v
^ | +------->| cPropertyClass |==v==>v
^ | | o----------------o v v
^ | | v v
^ o---------------o o----------------o v v
^ #==>| PropertyClass |===>| pPropertyClass |==================>v v
^ ^ o---------------o o----------------o v v
^ ^ v v
^ #=============================================================# v
^ v
#====================================================================#
where
-> means 'subclass of'
=> means 'instance of'
Pascal Bourguignon wrote:
Laurent Deniau <laurent.deniau@cern.ch> writes:
Jean-Marc Bourguet wrote:
Pascal Bourguignon <pjb@informatimago.com> writes:
Laurent Deniau <laurent.deniau@cern.ch> writes:
Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Et où mets tu le pointeur vers la classe?
Ce n'est pas un pointeur, mais un id qui joue le meme role. Ci-dessus
il est dans "object members", c'est a dire les membres de Object.
(Pour moi, un système OO où les classes ne sont pas des objets (de
première classe!), ne vaut pas grand chose, mais c'est un avis
personnel).
Il se trouve que les classes sont des objets (de premiere classes).
Voici une partie de la hierarchie actuelle extraite des headers (a
lire avec fonte fixe!)
a+, ld.
COS classes, meta classes and property meta classes core hierarchy
follows the principle of 'uniform object oriented programming'
(e.g. everything-is-object) using the 'safe metaclass compatibility
model':
1) Behaviors are objects
2) Classes and generics are behaviors
3) Meta classes are classes
4) Property classes are meta classes
NIL
<- Nil (root/subclass of all class)
<- Any (root class of atoms)
<- TrueFalse (class)
<- True (class)
<- False (class)
<- Object (root class of instances)
[...]
Class
^
|
o---------o
NIL +---------->| cObject |==========#
^ | o---------o v
| | ^ v
o--------o o---------o | v
| Object |=========>| pObject |===========|===========# v
o--------o o---------o | v v
^ o-----------o v v
| +--------->| cBehavior |=====v==>v
| | o-----------o v v
| | ^ v v
o----------o o-----------o | v v
| Behavior |=======>| pBehavior |==========|==========>v v
o----------o o-----------o | v v
^ o--------o v v
| +---------->| cClass |=======v==>v
| | o--------o v v
| | ^ v v
o-------o o--------o | v v
| Class |==========>| pClass |============|==========>v v
o-------o o--------o | v v
^ o------------o v v
| +-------->| cMetaClass |=====v==>v
| | o------------o v v
| | ^ v v
o-----------o o------------o | v v
#=======>| MetaClass |=======>| pMetaClass |=========|==========>v v
^ o-----------o o------------o | v v
^ ^ o----------------o v v
^ | +------->| cPropertyClass |==v==>v
^ | | o----------------o v v
^ | | v v
^ o---------------o o----------------o v v
^ #==>| PropertyClass |===>| pPropertyClass |==================>v v
^ ^ o---------------o o----------------o v v
^ ^ v v
^ #=============================================================# v
^ v
#====================================================================#
where
-> means 'subclass of'
=> means 'instance of'
Pascal Bourguignon wrote:Laurent Deniau writes:Jean-Marc Bourguet wrote:Pascal Bourguignon writes:Laurent Deniau writes:Est-ce que vous connaitriez un moyen de declarer une structure vide
sans declancher un warning de la part du compilateur?
Pas à ma connaissance. Que veux tu faire?
Ameliorer son framework objet je suppose.
Gagne ;-)
Actuellement, j'ai trois objets racine: Object, Any et Nil. Nil est un
cas particulier (absordant). En revanche, j'aurais aime que Object
derive de Any, ou Any serait une classe abstraite sans champ. Donc un
equivalent de
struct Any {};
struct Object {
struct Any Any;
// object members
};
Et où mets tu le pointeur vers la classe?
Ce n'est pas un pointeur, mais un id qui joue le meme role. Ci-dessus
il est dans "object members", c'est a dire les membres de Object.(Pour moi, un système OO où les classes ne sont pas des objets (de
première classe!), ne vaut pas grand chose, mais c'est un avis
personnel).
Il se trouve que les classes sont des objets (de premiere classes).
Voici une partie de la hierarchie actuelle extraite des headers (a
lire avec fonte fixe!)
a+, ld.
COS classes, meta classes and property meta classes core hierarchy
follows the principle of 'uniform object oriented programming'
(e.g. everything-is-object) using the 'safe metaclass compatibility
model':
1) Behaviors are objects
2) Classes and generics are behaviors
3) Meta classes are classes
4) Property classes are meta classes
NIL
<- Nil (root/subclass of all class)
<- Any (root class of atoms)
<- TrueFalse (class)
<- True (class)
<- False (class)
<- Object (root class of instances)
[...]
Class
^
|
o---------o
NIL +---------->| cObject |==========#
^ | o---------o v
| | ^ v
o--------o o---------o | v
| Object |=========>| pObject |===========|===========# v
o--------o o---------o | v v
^ o-----------o v v
| +--------->| cBehavior |=====v==>v
| | o-----------o v v
| | ^ v v
o----------o o-----------o | v v
| Behavior |=======>| pBehavior |==========|==========>v v
o----------o o-----------o | v v
^ o--------o v v
| +---------->| cClass |=======v==>v
| | o--------o v v
| | ^ v v
o-------o o--------o | v v
| Class |==========>| pClass |============|==========>v v
o-------o o--------o | v v
^ o------------o v v
| +-------->| cMetaClass |=====v==>v
| | o------------o v v
| | ^ v v
o-----------o o------------o | v v
#=======>| MetaClass |=======>| pMetaClass |=========|==========>v v
^ o-----------o o------------o | v v
^ ^ o----------------o v v
^ | +------->| cPropertyClass |==v==>v
^ | | o----------------o v v
^ | | v v
^ o---------------o o----------------o v v
^ #==>| PropertyClass |===>| pPropertyClass |==================>v v
^ ^ o---------------o o----------------o v v
^ ^ v v
^ #=============================================================# v
^ v
#====================================================================#
where
-> means 'subclass of'
=> means 'instance of'
Oui, c'est joli. Mais pourquoi a-t'on besoin d'Any?
Ne pourrait on pas avoir simplement Nil
et TrueFalse (Boolean!)
sous-classes d'Object?
(Ou une sous-classe Atom si on prévoit d'autres atomes).
Oui, c'est joli. Mais pourquoi a-t'on besoin d'Any?
Ne pourrait on pas avoir simplement Nil
et TrueFalse (Boolean!)
sous-classes d'Object?
(Ou une sous-classe Atom si on prévoit d'autres atomes).
Oui, c'est joli. Mais pourquoi a-t'on besoin d'Any?
Ne pourrait on pas avoir simplement Nil
et TrueFalse (Boolean!)
sous-classes d'Object?
(Ou une sous-classe Atom si on prévoit d'autres atomes).
NIL
<- Nil (root/subclass of all class)
<- Any (root class of atoms)
<- TrueFalse (class)
<- True (class)
<- False (class)
<- Object (root class of instances)
<- Method +[1234] (class)
<- Behavior (class)
<- Generic (class)
<- Class (class)
<- MetaClass (class)
<- PropertyClass (class)
<- cNil (meta class)
<- pNil (property class)
<- cTrueFalse (meta class)
<- pTrueFalse (property class)
<- cTrue (meta class)
<- pTrue (property class)
<- cFalse (meta class)
<- pFalse (property class)
<- cObject (meta class)
[...]
NIL
<- Nil (root/subclass of all class)
<- Any (root class of atoms)
<- TrueFalse (class)
<- True (class)
<- False (class)
<- Object (root class of instances)
<- Method +[1234] (class)
<- Behavior (class)
<- Generic (class)
<- Class (class)
<- MetaClass (class)
<- PropertyClass (class)
<- cNil (meta class)
<- pNil (property class)
<- cTrueFalse (meta class)
<- pTrueFalse (property class)
<- cTrue (meta class)
<- pTrue (property class)
<- cFalse (meta class)
<- pFalse (property class)
<- cObject (meta class)
[...]
NIL
<- Nil (root/subclass of all class)
<- Any (root class of atoms)
<- TrueFalse (class)
<- True (class)
<- False (class)
<- Object (root class of instances)
<- Method +[1234] (class)
<- Behavior (class)
<- Generic (class)
<- Class (class)
<- MetaClass (class)
<- PropertyClass (class)
<- cNil (meta class)
<- pNil (property class)
<- cTrueFalse (meta class)
<- pTrueFalse (property class)
<- cTrue (meta class)
<- pTrue (property class)
<- cFalse (meta class)
<- pFalse (property class)
<- cObject (meta class)
[...]