Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Patrick 'Zener' Brunet
Bonjour.
Je réponds à meow
Y a t'il une façon propre de gérer un "handle sur rien" ?
Quel est le contexte ?
1) Une variable de type "handle" qui n'est pas ou plus assignée à une entité valide (contexte de programmation purement "mécanique") ?
2) Une variable de type "handle" qui désigne explicitement "rien" (contexte de raisonnement "intelligent") ?
Dans le cas 1 et quelle que soit l'API utilisée, il est effectivement nécessaire qu'il existe une valeur jamais valide comme pour les pointeurs, en général 0 mais parfois -1 (ou autre). Ca dépend de l'implémentation du "handle". Ensuite le choix d'assigner directement 0 ou une valeur symbolique (sous la forme d'une macro ou d'une valeur d'enum) relève de réflexions plus ou moins teintées d'idéologies, et connues pour déchaîner les passions... Comme les "handles" sont souvent implémentés sous forme de pointeurs non documentés, et ceci depuis avant que le type enum fonctionne bien partout, cette valeur symbolique est souvent assimilée à la macro NULL, ce qui n'est pas forcément très subtil (à cause du mélange pointeur/handle d'une part, et du mauvais contrôle de la portée des macros d'autre part). /* j'ai été assez ouvert et diplomate là ? :-) */
Dans le cas 2 et comme le précisait Raymond Devos, rien n'est pas rien, et donc il doit exister une entité du modèle qui représente "rien", souvent nommée "nil", et donc c'est le handle de cette entité valide qui est assigné à un "handle sur rien" (ce qui permet donc au moteur de raisonnement d'accéder à ce "rien").
Vous programmez quoi et avec quel type de librairies ?
Cordialement,
-- /*************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe ***************************************/
Bonjour.
Je réponds à meow <ben@agat.net>
Y a t'il une façon propre de gérer un "handle sur rien" ?
Quel est le contexte ?
1) Une variable de type "handle" qui n'est pas ou plus assignée à une entité
valide (contexte de programmation purement "mécanique") ?
2) Une variable de type "handle" qui désigne explicitement "rien" (contexte
de raisonnement "intelligent") ?
Dans le cas 1 et quelle que soit l'API utilisée, il est effectivement
nécessaire qu'il existe une valeur jamais valide comme pour les pointeurs,
en général 0 mais parfois -1 (ou autre). Ca dépend de l'implémentation du
"handle".
Ensuite le choix d'assigner directement 0 ou une valeur symbolique (sous la
forme d'une macro ou d'une valeur d'enum) relève de réflexions plus ou moins
teintées d'idéologies, et connues pour déchaîner les passions...
Comme les "handles" sont souvent implémentés sous forme de pointeurs non
documentés, et ceci depuis avant que le type enum fonctionne bien partout,
cette valeur symbolique est souvent assimilée à la macro NULL, ce qui n'est
pas forcément très subtil (à cause du mélange pointeur/handle d'une part, et
du mauvais contrôle de la portée des macros d'autre part).
/* j'ai été assez ouvert et diplomate là ? :-) */
Dans le cas 2 et comme le précisait Raymond Devos, rien n'est pas rien, et
donc il doit exister une entité du modèle qui représente "rien", souvent
nommée "nil", et donc c'est le handle de cette entité valide qui est assigné
à un "handle sur rien" (ce qui permet donc au moteur de raisonnement
d'accéder à ce "rien").
Vous programmez quoi et avec quel type de librairies ?
Cordialement,
--
/***************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
***************************************/
Y a t'il une façon propre de gérer un "handle sur rien" ?
Quel est le contexte ?
1) Une variable de type "handle" qui n'est pas ou plus assignée à une entité valide (contexte de programmation purement "mécanique") ?
2) Une variable de type "handle" qui désigne explicitement "rien" (contexte de raisonnement "intelligent") ?
Dans le cas 1 et quelle que soit l'API utilisée, il est effectivement nécessaire qu'il existe une valeur jamais valide comme pour les pointeurs, en général 0 mais parfois -1 (ou autre). Ca dépend de l'implémentation du "handle". Ensuite le choix d'assigner directement 0 ou une valeur symbolique (sous la forme d'une macro ou d'une valeur d'enum) relève de réflexions plus ou moins teintées d'idéologies, et connues pour déchaîner les passions... Comme les "handles" sont souvent implémentés sous forme de pointeurs non documentés, et ceci depuis avant que le type enum fonctionne bien partout, cette valeur symbolique est souvent assimilée à la macro NULL, ce qui n'est pas forcément très subtil (à cause du mélange pointeur/handle d'une part, et du mauvais contrôle de la portée des macros d'autre part). /* j'ai été assez ouvert et diplomate là ? :-) */
Dans le cas 2 et comme le précisait Raymond Devos, rien n'est pas rien, et donc il doit exister une entité du modèle qui représente "rien", souvent nommée "nil", et donc c'est le handle de cette entité valide qui est assigné à un "handle sur rien" (ce qui permet donc au moteur de raisonnement d'accéder à ce "rien").
Vous programmez quoi et avec quel type de librairies ?
Cordialement,
-- /*************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe ***************************************/
James Kanze
meow wrote:
Y a t'il une façon propre de gérer un "handle sur rien" ?
Ça dépend de l'implémentation du handle. Fallible marche toujours, à condition que le handle à un constructeur par défaut. Si le handle est en fait un pointeur (typedef à void*, par exemple, mais aussi à d'autres types, du genre FILE*), NULL fait l'affaire. Si le handle est un int, dont le contenu est un petit entier non-négatif (genre fileid de Unix), -1 fait l'affaire ; dans certain cas, INT_MAX ou UINT_MAX marche aussi.
Il n'y a malheureusement pas de solution universelle. Dans le cas où l'interface définie une valeur (assez souvent le cas, quand elle a besoin d'une valeur de rétour elle-même pour des fonctions de création ou de récherche), c'est naturellement elle qui sert. Dans le cas garantis d'être des pointeurs, comme FILE* en C, j'utilise NULL. Chaque fois qu'il y a une doute, j'utilise Fallible.
-- James Kanze mailto: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
meow wrote:
Y a t'il une façon propre de gérer un "handle sur rien" ?
Ça dépend de l'implémentation du handle. Fallible marche
toujours, à condition que le handle à un constructeur par
défaut. Si le handle est en fait un pointeur (typedef à void*,
par exemple, mais aussi à d'autres types, du genre FILE*), NULL
fait l'affaire. Si le handle est un int, dont le contenu est un
petit entier non-négatif (genre fileid de Unix), -1 fait
l'affaire ; dans certain cas, INT_MAX ou UINT_MAX marche aussi.
Il n'y a malheureusement pas de solution universelle. Dans le
cas où l'interface définie une valeur (assez souvent le cas,
quand elle a besoin d'une valeur de rétour elle-même pour des
fonctions de création ou de récherche), c'est naturellement elle
qui sert. Dans le cas garantis d'être des pointeurs, comme FILE*
en C, j'utilise NULL. Chaque fois qu'il y a une doute, j'utilise
Fallible.
--
James Kanze mailto: james.kanze@free.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
Y a t'il une façon propre de gérer un "handle sur rien" ?
Ça dépend de l'implémentation du handle. Fallible marche toujours, à condition que le handle à un constructeur par défaut. Si le handle est en fait un pointeur (typedef à void*, par exemple, mais aussi à d'autres types, du genre FILE*), NULL fait l'affaire. Si le handle est un int, dont le contenu est un petit entier non-négatif (genre fileid de Unix), -1 fait l'affaire ; dans certain cas, INT_MAX ou UINT_MAX marche aussi.
Il n'y a malheureusement pas de solution universelle. Dans le cas où l'interface définie une valeur (assez souvent le cas, quand elle a besoin d'une valeur de rétour elle-même pour des fonctions de création ou de récherche), c'est naturellement elle qui sert. Dans le cas garantis d'être des pointeurs, comme FILE* en C, j'utilise NULL. Chaque fois qu'il y a une doute, j'utilise Fallible.
-- James Kanze mailto: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
