Dans ma qu=EAte du "toujours plus propre", je suis en train d'essayer
de g=E9n=E9riciser un algorithme =E0 coup de pr=E9dicats param=E9trables
(comprendre : on les donne en param=E8tre... voire en classe de trait
s'il s'av=E8re que leur nombre devient r=E9dhibitoire au cours du
d=E9veloppement.).
Bref, pour cela il va falloir que j'apprenne =E0 les utiliser, ces
pr=E9dicats, et c'est loin d'=EAtre le cas. Jusqu'=E0 pr=E9sent je n'ai r=E9=
ussi
=E0 atteindre mon but qu'en utilisant unary_function< >, aussi me
demandais-je si predicate< > n'=E9tait tout simplement pas
impl=E9mentable ?
Les questions, donc :
a.) que signifie *exactement* le terme "Concept" dans la doc de la
stl ? A priori j'aurai dit que c'est un accord tacite sans code...
mais unary_function existe et je peux en h=E9riter...
b.) est-ce que je peux utiliser un predicate<Point> ou =E7a n'existe pas
et j'ai donc raison d'utiliser unary_function<Point,bool> =E0 la place ?
c.) s'il y a moyen d'utiliser predicate, j'imagine que c'est plus
propre, comment je fais ?
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
meow
Je précises mes questions :
Dans le cadre d'une application, j'ai besoin de savoir si telle ou telle molécule d'eau est à l'intérieur d'une protéine (modélisée par un polyèdre (représenté par une classe HDS) ). J'ai donc écrit une classe prédicat :
class PointExteriorToHDS : public std::unary_function< Point ,bool> { protected: HDS const& hds; public: PointExteriorToHDS(HDS const& H):hds(H){} public: bool operator()(Point const& water) const { } }
qui me permet entre autre d'utiliser "negate" lorsque j'en ai besoin.
Est-ce propre ? Ais-je oublié quelque chose ? Pourquoi est-ce que j'arrive à dériver std::unary_function et pas std::predicate alors que tous deux sont documentés comme concepts dans le manuel de la stl ? (manuel SGI online)
Je précises mes questions :
Dans le cadre d'une application, j'ai besoin de savoir si telle ou
telle molécule d'eau est à l'intérieur d'une protéine (modélisée par
un polyèdre (représenté par une classe HDS) ). J'ai donc écrit une
classe prédicat :
class PointExteriorToHDS : public std::unary_function< Point ,bool> {
protected:
HDS const& hds;
public:
PointExteriorToHDS(HDS const& H):hds(H){}
public:
bool operator()(Point const& water) const {
}
}
qui me permet entre autre d'utiliser "negate" lorsque j'en ai besoin.
Est-ce propre ? Ais-je oublié quelque chose ? Pourquoi est-ce que
j'arrive à dériver std::unary_function et pas std::predicate alors que
tous deux sont documentés comme concepts dans le manuel de la stl ?
(manuel SGI online)
Dans le cadre d'une application, j'ai besoin de savoir si telle ou telle molécule d'eau est à l'intérieur d'une protéine (modélisée par un polyèdre (représenté par une classe HDS) ). J'ai donc écrit une classe prédicat :
class PointExteriorToHDS : public std::unary_function< Point ,bool> { protected: HDS const& hds; public: PointExteriorToHDS(HDS const& H):hds(H){} public: bool operator()(Point const& water) const { } }
qui me permet entre autre d'utiliser "negate" lorsque j'en ai besoin.
Est-ce propre ? Ais-je oublié quelque chose ? Pourquoi est-ce que j'arrive à dériver std::unary_function et pas std::predicate alors que tous deux sont documentés comme concepts dans le manuel de la stl ? (manuel SGI online)
Michael DOUBEZ
Je précises mes questions :
Dans le cadre d'une application, j'ai besoin de savoir si telle ou telle molécule d'eau est à l'intérieur d'une protéine (modélisée par un polyèdre (représenté par une classe HDS) ). J'ai donc écrit une classe prédicat :
class PointExteriorToHDS : public std::unary_function< Point ,bool> { protected: HDS const& hds; public: PointExteriorToHDS(HDS const& H):hds(H){} public: bool operator()(Point const& water) const { } }
qui me permet entre autre d'utiliser "negate" lorsque j'en ai besoin.
Est-ce propre ? Ais-je oublié quelque chose ? Pourquoi est-ce que j'arrive à dériver std::unary_function et pas std::predicate alors que tous deux sont documentés comme concepts dans le manuel de la stl ? (manuel SGI online)
Je n'ai pas vu de std::predicate dans la doc SGI.
Il y a le concept de Predicate mais, pour autant que je sache, il n'a pas de correspondance autre que std::unary_function<T,BOOL_TYPE> comme tu l'as écris.
Michael
Je précises mes questions :
Dans le cadre d'une application, j'ai besoin de savoir si telle ou
telle molécule d'eau est à l'intérieur d'une protéine (modélisée par
un polyèdre (représenté par une classe HDS) ). J'ai donc écrit une
classe prédicat :
class PointExteriorToHDS : public std::unary_function< Point ,bool> {
protected:
HDS const& hds;
public:
PointExteriorToHDS(HDS const& H):hds(H){}
public:
bool operator()(Point const& water) const {
}
}
qui me permet entre autre d'utiliser "negate" lorsque j'en ai besoin.
Est-ce propre ? Ais-je oublié quelque chose ? Pourquoi est-ce que
j'arrive à dériver std::unary_function et pas std::predicate alors que
tous deux sont documentés comme concepts dans le manuel de la stl ?
(manuel SGI online)
Je n'ai pas vu de std::predicate dans la doc SGI.
Il y a le concept de Predicate mais, pour autant que je sache, il n'a
pas de correspondance autre que std::unary_function<T,BOOL_TYPE> comme
tu l'as écris.
Dans le cadre d'une application, j'ai besoin de savoir si telle ou telle molécule d'eau est à l'intérieur d'une protéine (modélisée par un polyèdre (représenté par une classe HDS) ). J'ai donc écrit une classe prédicat :
class PointExteriorToHDS : public std::unary_function< Point ,bool> { protected: HDS const& hds; public: PointExteriorToHDS(HDS const& H):hds(H){} public: bool operator()(Point const& water) const { } }
qui me permet entre autre d'utiliser "negate" lorsque j'en ai besoin.
Est-ce propre ? Ais-je oublié quelque chose ? Pourquoi est-ce que j'arrive à dériver std::unary_function et pas std::predicate alors que tous deux sont documentés comme concepts dans le manuel de la stl ? (manuel SGI online)
Je n'ai pas vu de std::predicate dans la doc SGI.
Il y a le concept de Predicate mais, pour autant que je sache, il n'a pas de correspondance autre que std::unary_function<T,BOOL_TYPE> comme tu l'as écris.
Michael
meow
Bonjour, et merci pour cette réponse
Je n'ai pas vu de std::predicate dans la doc SGI.
Oui, moi non plus
Il y a le concept de Predicate mais, pour autant que je sache, il n'a
Tout à fait, mais je n'ai pas vu de std::unary_function non plus dans la doc, je n'ai vu que le concept (ais-je mal cherché ?). Pourtant la classe unary_function existe et se dérive. J'en avais inféré que Predicate devait certainement aussi se dériver d'une manière ou d'une autre. Merci d'avoir confirmé que ce n'est pas le cas.
Bonjour, et merci pour cette réponse
Je n'ai pas vu de std::predicate dans la doc SGI.
Oui, moi non plus
Il y a le concept de Predicate mais, pour autant que je sache, il n'a
Tout à fait, mais je n'ai pas vu de std::unary_function non plus dans
la doc, je n'ai vu que le concept (ais-je mal cherché ?). Pourtant la
classe unary_function existe et se dérive. J'en avais inféré que
Predicate devait certainement aussi se dériver d'une manière ou d'une
autre.
Merci d'avoir confirmé que ce n'est pas le cas.
Il y a le concept de Predicate mais, pour autant que je sache, il n'a
Tout à fait, mais je n'ai pas vu de std::unary_function non plus dans la doc, je n'ai vu que le concept (ais-je mal cherché ?). Pourtant la classe unary_function existe et se dérive. J'en avais inféré que Predicate devait certainement aussi se dériver d'une manière ou d'une autre. Merci d'avoir confirmé que ce n'est pas le cas.
Michael DOUBEZ
Bonjour,
Dans ma quête du "toujours plus propre", je suis en train d'essayer de génériciser un algorithme à coup de prédicats paramétrables (comprendre : on les donne en paramètre... voire en classe de trait s'il s'avère que leur nombre devient rédhibitoire au cours du développement.). Bref, pour cela il va falloir que j'apprenne à les utiliser, ces prédicats, et c'est loin d'être le cas. Jusqu'à présent je n'ai réussi à atteindre mon but qu'en utilisant unary_function< >, aussi me demandais-je si predicate< > n'était tout simplement pas implémentable ?
Les questions, donc : a.) que signifie *exactement* le terme "Concept" dans la doc de la stl ? A priori j'aurai dit que c'est un accord tacite sans code... mais unary_function existe et je peux en hériter...
unary_function definit des typedefs. Il est de la forme:
template <class Arg, class Result> struct unary_function { typedef Arg argument_type; typedef Result result_type; };
b.) est-ce que je peux utiliser un predicate<Point> ou ça n'existe pas et j'ai donc raison d'utiliser unary_function<Point,bool> à la place ?
Tu as raison.
c.) s'il y a moyen d'utiliser predicate, j'imagine que c'est plus propre, comment je fais ?
Dans ma quête du "toujours plus propre", je suis en train d'essayer
de génériciser un algorithme à coup de prédicats paramétrables
(comprendre : on les donne en paramètre... voire en classe de trait
s'il s'avère que leur nombre devient rédhibitoire au cours du
développement.).
Bref, pour cela il va falloir que j'apprenne à les utiliser, ces
prédicats, et c'est loin d'être le cas. Jusqu'à présent je n'ai réussi
à atteindre mon but qu'en utilisant unary_function< >, aussi me
demandais-je si predicate< > n'était tout simplement pas
implémentable ?
Les questions, donc :
a.) que signifie *exactement* le terme "Concept" dans la doc de la
stl ? A priori j'aurai dit que c'est un accord tacite sans code...
mais unary_function existe et je peux en hériter...
unary_function definit des typedefs. Il est de la forme:
template <class Arg, class Result>
struct unary_function
{
typedef Arg argument_type;
typedef Result result_type;
};
b.) est-ce que je peux utiliser un predicate<Point> ou ça n'existe pas
et j'ai donc raison d'utiliser unary_function<Point,bool> à la place ?
Tu as raison.
c.) s'il y a moyen d'utiliser predicate, j'imagine que c'est plus
propre, comment je fais ?
Dans ma quête du "toujours plus propre", je suis en train d'essayer de génériciser un algorithme à coup de prédicats paramétrables (comprendre : on les donne en paramètre... voire en classe de trait s'il s'avère que leur nombre devient rédhibitoire au cours du développement.). Bref, pour cela il va falloir que j'apprenne à les utiliser, ces prédicats, et c'est loin d'être le cas. Jusqu'à présent je n'ai réussi à atteindre mon but qu'en utilisant unary_function< >, aussi me demandais-je si predicate< > n'était tout simplement pas implémentable ?
Les questions, donc : a.) que signifie *exactement* le terme "Concept" dans la doc de la stl ? A priori j'aurai dit que c'est un accord tacite sans code... mais unary_function existe et je peux en hériter...
unary_function definit des typedefs. Il est de la forme:
template <class Arg, class Result> struct unary_function { typedef Arg argument_type; typedef Result result_type; };
b.) est-ce que je peux utiliser un predicate<Point> ou ça n'existe pas et j'ai donc raison d'utiliser unary_function<Point,bool> à la place ?
Tu as raison.
c.) s'il y a moyen d'utiliser predicate, j'imagine que c'est plus propre, comment je fais ?
Il y a le concept de Predicate mais, pour autant que je sache, il n'a
Tout à fait, mais je n'ai pas vu de std::unary_function non plus dans la doc, je n'ai vu que le concept (ais-je mal cherché ?). Pourtant la classe unary_function existe et se dérive. J'en avais inféré que Predicate devait certainement aussi se dériver d'une manière ou d'une autre. Merci d'avoir confirmé que ce n'est pas le cas.
http://www.sgi.com/tech/stl/unary_function.html
" Definition Defined in the standard header functional, and in the nonstandard backward-compatibility header function.h. "
Donc c'est défini (ce qui n'est pas le cas de predicate).
D'une manière générale, la doc SGI ne correspond pas toujours au standard. Il y a même une quantité de fonctor qui seraient bien utiles mais bon ... c'est le comité qui décide.
Juste pour noter, dans un de tes mail précédents tu voulais utiliser negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu doit vouloir arler de logical_not qui réalise b->!b.
Michael
Bonjour, et merci pour cette réponse
Je n'ai pas vu de std::predicate dans la doc SGI.
Oui, moi non plus
Il y a le concept de Predicate mais, pour autant que je sache, il n'a
Tout à fait, mais je n'ai pas vu de std::unary_function non plus dans
la doc, je n'ai vu que le concept (ais-je mal cherché ?). Pourtant la
classe unary_function existe et se dérive. J'en avais inféré que
Predicate devait certainement aussi se dériver d'une manière ou d'une
autre.
Merci d'avoir confirmé que ce n'est pas le cas.
http://www.sgi.com/tech/stl/unary_function.html
"
Definition
Defined in the standard header functional, and in the nonstandard
backward-compatibility header function.h.
"
Donc c'est défini (ce qui n'est pas le cas de predicate).
D'une manière générale, la doc SGI ne correspond pas toujours au
standard. Il y a même une quantité de fonctor qui seraient bien utiles
mais bon ... c'est le comité qui décide.
Juste pour noter, dans un de tes mail précédents tu voulais utiliser
negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu
doit vouloir arler de logical_not qui réalise b->!b.
Il y a le concept de Predicate mais, pour autant que je sache, il n'a
Tout à fait, mais je n'ai pas vu de std::unary_function non plus dans la doc, je n'ai vu que le concept (ais-je mal cherché ?). Pourtant la classe unary_function existe et se dérive. J'en avais inféré que Predicate devait certainement aussi se dériver d'une manière ou d'une autre. Merci d'avoir confirmé que ce n'est pas le cas.
http://www.sgi.com/tech/stl/unary_function.html
" Definition Defined in the standard header functional, and in the nonstandard backward-compatibility header function.h. "
Donc c'est défini (ce qui n'est pas le cas de predicate).
D'une manière générale, la doc SGI ne correspond pas toujours au standard. Il y a même une quantité de fonctor qui seraient bien utiles mais bon ... c'est le comité qui décide.
Juste pour noter, dans un de tes mail précédents tu voulais utiliser negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu doit vouloir arler de logical_not qui réalise b->!b.
Je m'étais arrêté à la table of content http://www.sgi.com/tech/stl/table_of_contents.html à laquelle figure un certain nombre de types, mais pas ceux là... Désolé. Et merci, je serai plus vigilant à l'avenir.
Juste pour noter, dans un de tes mail précédents tu voulais utiliser negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu doit vouloir arler de logical_not qui réalise b->!b.
Je ne suis pas encore "pro" dans l'utilisation de ces fontionnalités et j'écrivais de tête. Merci d'avoir corrigé. En fait, après vérification, j'avais utilisé std::unary_negate.
Je m'étais arrêté à la table of content
http://www.sgi.com/tech/stl/table_of_contents.html
à laquelle figure un certain nombre de types, mais pas ceux là...
Désolé. Et merci, je serai plus vigilant à l'avenir.
Juste pour noter, dans un de tes mail précédents tu voulais utiliser
negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu
doit vouloir arler de logical_not qui réalise b->!b.
Je ne suis pas encore "pro" dans l'utilisation de ces fontionnalités
et j'écrivais de tête. Merci d'avoir corrigé. En fait, après
vérification, j'avais utilisé std::unary_negate.
Je m'étais arrêté à la table of content http://www.sgi.com/tech/stl/table_of_contents.html à laquelle figure un certain nombre de types, mais pas ceux là... Désolé. Et merci, je serai plus vigilant à l'avenir.
Juste pour noter, dans un de tes mail précédents tu voulais utiliser negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu doit vouloir arler de logical_not qui réalise b->!b.
Je ne suis pas encore "pro" dans l'utilisation de ces fontionnalités et j'écrivais de tête. Merci d'avoir corrigé. En fait, après vérification, j'avais utilisé std::unary_negate.
--Ben
James Kanze
On Jan 30, 3:11 pm, Michael DOUBEZ wrote:
[...]
Juste pour noter, dans un de tes mail précédents tu voulais utiliser negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu doit vouloir arler de logical_not qui réalise b->!b.
En général, on utiliserait plus souvent std::not1 ou std::not2, je crois. Des fonctions qui renvoient un std::logical_not, mais parce qu'elles sont des fonctions, la déduction automatique des types se fait, et donc, on n'a pas besoin de les préciser explicitement.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
On Jan 30, 3:11 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:
[...]
Juste pour noter, dans un de tes mail précédents tu voulais
utiliser negate mais negate n'agit pas sur des prédicats, il
réalise t->-t. Tu doit vouloir arler de logical_not qui
réalise b->!b.
En général, on utiliserait plus souvent std::not1 ou std::not2,
je crois. Des fonctions qui renvoient un std::logical_not, mais
parce qu'elles sont des fonctions, la déduction automatique des
types se fait, et donc, on n'a pas besoin de les préciser
explicitement.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Juste pour noter, dans un de tes mail précédents tu voulais utiliser negate mais negate n'agit pas sur des prédicats, il réalise t->-t. Tu doit vouloir arler de logical_not qui réalise b->!b.
En général, on utiliserait plus souvent std::not1 ou std::not2, je crois. Des fonctions qui renvoient un std::logical_not, mais parce qu'elles sont des fonctions, la déduction automatique des types se fait, et donc, on n'a pas besoin de les préciser explicitement.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
