struct vide

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:

-*- mode: compilation; default-directory: "/tmp/" -*-
Compilation started at Tue Jan 9 13:28:53

cat z.c ; make z && ./z
#include <stdio.h>

struct A {
char empty[0];
};

struct A x;

int main (void){
printf("size=%dn",sizeof(struct A));
printf("size=%dn",sizeof(x));
return(0);
}
make: `z' is up to date.
size=0
size=0

Compilation finished at Tue Jan 9 13:28:54


--
__Pascal Bourguignon__ http://www.informatimago.com/

PLEASE NOTE: Some quantum physics theories suggest that when the
consumer is not directly observing this product, it may cease to
exist or will exist only in a vague and undetermined state.

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.

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:

C'est une extension de gcc.

--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org

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
};

Actuellement Any est la classe racine des classes predicat qui par
definition sont toutes abstraites (propriete heritee). Donc jusqu'a
maintenant, je n'ai pas eu de probleme a la definir comme

struct Any {
char _;
};

puisqu'aucune instance ne sera jamais creee. Ce qui n'est plus le cas si
Object en derive. Donc pour "unifier" les deux hierarchies, je cherche a
faire de Any une structure vide.

La seule solution que j'ai trouve pour l'instant mais qui ne me plait
pas c'est de deplacer dans Any les champs de Object. Mais ce n'est pas
elegant ni justifiable.

Pour ce qui est de du tableau vide, j'ai le warning:
warning: ISO C forbids zero-size array
qui n'est pas mieux que
warning: struct has no members
ou
warning: struct has no named members

a+, ld.

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).


--
__Pascal Bourguignon__ http://www.informatimago.com/

Pour moi, la grande question n'a jamais été: «Qui suis-je? Où vais-je?»
comme l'a formulé si adroitement notre ami Pascal, mais plutôt:
«Comment vais-je m'en tirer?» -- Jean Yanne

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)
<- 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)
<- pObject (property class)
<- cMethod +[1234] (meta class)
<- pMethod +[1234] (property class)
<- cBehavior (meta class)
<- pBehavior (property class)
<- cGeneric (meta class)
<- pGeneric (property class)
<- cClass (meta class)
<- pGeneric (property class)
<- cMetaClass (meta class)
<- pMetaClass (property class)
<- cPropertyClass (meta class)
<- pPropertyClass (property class)


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'

Laurent Deniau <laurent.deniau@cern.ch> writes:

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'

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).

--
__Pascal Bourguignon__ http://www.informatimago.com/
The rule for today:
Touch my tail, I shred your hand.
New rule tomorrow.

Pascal Bourguignon wrote:

Oui, c'est joli. Mais pourquoi a-t'on besoin d'Any?

Juste pour unifier les hierarchies comme dans Eiffel. Rien d'autre.

Ne pourrait on pas avoir simplement Nil

Nil est special. Il est absorbant (repond a n'importe quel message) ce
qui est equivalent d'etre une subclass de toutes les classes.

et TrueFalse (Boolean!)

Non, TrueFalse n'est pas Boolean parce qu'il peut, suivant l'utilisation
que l'on en fait, representer un etat en soi (indetermine, incertain).

sous-classes d'Object?

Object fourni entre autre l'allocateur par defaut pour creer des
instances, or TrueFalse est une classe predicat (pas d'instance) donc il
ne peut pas en deriver.

(Ou une sous-classe Atom si on prévoit d'autres atomes).

Atom est effectivement une solution comme racine des classes predicats
qui m'a effleurer et que j'adopterais probablement si je n'arrive pas a
unifier les deux hierarchies proprement:

-- C1 <--
/
Any <--- C2 <---- Nil
/
-- C3 <--

a+, ld.

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?

C'est invalide en C, alors...
Du moins, si je comprends bien ce que tu appelles « struct vide ».

-- Gaby

Pascal Bourguignon <pjb@informatimago.com> writes:


[...]

| -*- mode: compilation; default-directory: "/tmp/" -*-
| Compilation started at Tue Jan 9 13:28:53
|
| cat z.c ; make z && ./z
| #include <stdio.h>
|
| struct A {
| char empty[0];
| };

C n'autorise pas cela, je crois.

-- Gaby

In article <eo09ut$73j$1@cernne03.cern.ch>,
Laurent Deniau <laurent.deniau@cern.ch> wrote:

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)
[...]

Oh, le joli sapin.

Joyeux Noel a toi-aussi.

(desole, j'ai pas pu resister).