Bonjour,
Je travaille actuellement sur des polygones, J'ai créé une structure
segment qui contient deux références vers des points.
J'ai écrit une fonction qui me fournit une suite de segments (avec le
segment qui fait la fermeture) quand je lui rentre une suite de points.
Tout cela marchait à peu près correctement, sauf quand j'utilisais une
série de points const parce que la structure segment n'assurait pas le
caractère constant des références. Ce problème m'a poussé à réécrire la
classe segment de manière template qui s'instantie à la fois pour des
points et des points const.
Malheureusement, ma fonction de génération de segments ne compile plus,
car je lui passe un output_iterator (en réalité un back_inserter) en
argument, qui a le mauvais goût d'avoir un ::value_type de type void,
d'après le standard.
En conséquence, inverser les commentaires des lignes 46 et 47 et
respectivement 49 et 50 du code suivant génère des erreurs de compilation.
Quelqu'un aurait-il une façon de rémédier à celà ou alors dois-je
complètement revoir le "design" de cette classe segment ?
merci d'avance pour vos éclaircissements
A. Fournier
--
Alexandre Fournier
INRIA - Projet ARIANA
2004 route des Lucioles - BP 93
06902 Sophia-Antipolis Cedex
FRANCE
Tel : 04-92-38-77-73
courriel : alexandre.fournier@sophia.inria.fr
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
Michel Decima
Tout cela marchait à peu près correctement, sauf quand j'utilisais une série de points const parce que la structure segment n'assurait pas le caractère constant des références. Ce problème m'a poussé à réécrire la classe segment de manière template qui s'instantie à la fois pour des points et des points const.
Malheureusement, ma fonction de génération de segments ne compile plus, car je lui passe un output_iterator (en réalité un back_inserter) en argument, qui a le mauvais goût d'avoir un ::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je m'etais demandé pourquoi ce choix...
Quelqu'un aurait-il une façon de rémédier à celà ou alors dois-je complètement revoir le "design" de cette classe segment ?
merci d'avance pour vos éclaircissements A. Fournier
Pour la classe base_segment, je n'utiliserais pas des references pour les membres, mais plutot des pointeurs. Ca va eviter les desagrements du genre:
int main() { int x, y, z, q; const_segment cs1( x, y ); const_segment cs2( z, q );
cs1 = cs2; }
alex.cpp: In member function base_segment<T>& base_segment<T>::operator=(const base_segment<T>&) [with T = const int]: alex.cpp:31: instantiated from here alex.cpp:16: erreur: assignment of read-only location alex.cpp:17: erreur: assignment of read-only location
Pour la fonction make_segment, il y a une solution qui consiste a passer par une classe intermediaire, avec les casts implicites qui vont bien:
template < typename T > class temp_segment { public: T* first_; T* second_; temp_segment(T& first,T& second) : first_(&first), second_(&second) {} operator base_segment< T >() const { return base_segment< T >( *first_, *second_ ); }
operator base_segment< const T >() const { return base_segment< const T >( *first_, *second_ ); } };
Avec ca, ton programme de depart compile, pour vector<segment> et vector<const_segment>.
Tout cela marchait à peu près correctement, sauf quand j'utilisais une
série de points const parce que la structure segment n'assurait pas le
caractère constant des références. Ce problème m'a poussé à réécrire la
classe segment de manière template qui s'instantie à la fois pour des
points et des points const.
Malheureusement, ma fonction de génération de segments ne compile plus,
car je lui passe un output_iterator (en réalité un back_inserter) en
argument, qui a le mauvais goût d'avoir un ::value_type de type void,
d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je
m'etais demandé pourquoi ce choix...
Quelqu'un aurait-il une façon de rémédier à celà ou alors dois-je
complètement revoir le "design" de cette classe segment ?
merci d'avance pour vos éclaircissements
A. Fournier
Pour la classe base_segment, je n'utiliserais pas des references pour
les membres, mais plutot des pointeurs. Ca va eviter les desagrements
du genre:
int main()
{
int x, y, z, q;
const_segment cs1( x, y );
const_segment cs2( z, q );
cs1 = cs2;
}
alex.cpp: In member function base_segment<T>&
base_segment<T>::operator=(const base_segment<T>&) [with T = const int]:
alex.cpp:31: instantiated from here
alex.cpp:16: erreur: assignment of read-only location
alex.cpp:17: erreur: assignment of read-only location
Pour la fonction make_segment, il y a une solution qui consiste a passer
par une classe intermediaire, avec les casts implicites qui vont bien:
template < typename T >
class temp_segment
{
public:
T* first_;
T* second_;
temp_segment(T& first,T& second)
: first_(&first),
second_(&second)
{}
operator base_segment< T >() const {
return base_segment< T >( *first_, *second_ );
}
operator base_segment< const T >() const {
return base_segment< const T >( *first_, *second_ );
}
};
Tout cela marchait à peu près correctement, sauf quand j'utilisais une série de points const parce que la structure segment n'assurait pas le caractère constant des références. Ce problème m'a poussé à réécrire la classe segment de manière template qui s'instantie à la fois pour des points et des points const.
Malheureusement, ma fonction de génération de segments ne compile plus, car je lui passe un output_iterator (en réalité un back_inserter) en argument, qui a le mauvais goût d'avoir un ::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je m'etais demandé pourquoi ce choix...
Quelqu'un aurait-il une façon de rémédier à celà ou alors dois-je complètement revoir le "design" de cette classe segment ?
merci d'avance pour vos éclaircissements A. Fournier
Pour la classe base_segment, je n'utiliserais pas des references pour les membres, mais plutot des pointeurs. Ca va eviter les desagrements du genre:
int main() { int x, y, z, q; const_segment cs1( x, y ); const_segment cs2( z, q );
cs1 = cs2; }
alex.cpp: In member function base_segment<T>& base_segment<T>::operator=(const base_segment<T>&) [with T = const int]: alex.cpp:31: instantiated from here alex.cpp:16: erreur: assignment of read-only location alex.cpp:17: erreur: assignment of read-only location
Pour la fonction make_segment, il y a une solution qui consiste a passer par une classe intermediaire, avec les casts implicites qui vont bien:
template < typename T > class temp_segment { public: T* first_; T* second_; temp_segment(T& first,T& second) : first_(&first), second_(&second) {} operator base_segment< T >() const { return base_segment< T >( *first_, *second_ ); }
operator base_segment< const T >() const { return base_segment< const T >( *first_, *second_ ); } };
Avec ca, ton programme de depart compile, pour vector<segment> et vector<const_segment>.
Michael DOUBEZ
Tout cela marchait à peu près correctement, sauf quand j'utilisais une série de points const parce que la structure segment n'assurait pas le caractère constant des références. Ce problème m'a poussé à réécrire la classe segment de manière template qui s'instantie à la fois pour des points et des points const.
Malheureusement, ma fonction de génération de segments ne compile plus, car je lui passe un output_iterator (en réalité un back_inserter) en argument, qui a le mauvais goût d'avoir un ::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je m'etais demandé pourquoi ce choix...
Je suppose que l'opérateur *() renvoit un objet proxy qui permet de faire l'insertion. Dans ce cas, un value_type signifiant aurait pu être source d'erreur.
Maintenant, c'est vrai qu'il ne doit pas être courant de manipuler une reference sur la valeur d'un output_iterator.
Michael
Tout cela marchait à peu près correctement, sauf quand j'utilisais une
série de points const parce que la structure segment n'assurait pas le
caractère constant des références. Ce problème m'a poussé à réécrire
la classe segment de manière template qui s'instantie à la fois pour
des points et des points const.
Malheureusement, ma fonction de génération de segments ne compile
plus, car je lui passe un output_iterator (en réalité un
back_inserter) en argument, qui a le mauvais goût d'avoir un
::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je
m'etais demandé pourquoi ce choix...
Je suppose que l'opérateur *() renvoit un objet proxy qui permet de
faire l'insertion. Dans ce cas, un value_type signifiant aurait pu être
source d'erreur.
Maintenant, c'est vrai qu'il ne doit pas être courant de manipuler une
reference sur la valeur d'un output_iterator.
Tout cela marchait à peu près correctement, sauf quand j'utilisais une série de points const parce que la structure segment n'assurait pas le caractère constant des références. Ce problème m'a poussé à réécrire la classe segment de manière template qui s'instantie à la fois pour des points et des points const.
Malheureusement, ma fonction de génération de segments ne compile plus, car je lui passe un output_iterator (en réalité un back_inserter) en argument, qui a le mauvais goût d'avoir un ::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je m'etais demandé pourquoi ce choix...
Je suppose que l'opérateur *() renvoit un objet proxy qui permet de faire l'insertion. Dans ce cas, un value_type signifiant aurait pu être source d'erreur.
Maintenant, c'est vrai qu'il ne doit pas être courant de manipuler une reference sur la valeur d'un output_iterator.
Michael
Michel Decima
Malheureusement, ma fonction de génération de segments ne compile plus, car je lui passe un output_iterator (en réalité un back_inserter) en argument, qui a le mauvais goût d'avoir un ::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je m'etais demandé pourquoi ce choix...
Je suppose que l'opérateur *() renvoit un objet proxy qui permet de faire l'insertion. Dans ce cas, un value_type signifiant aurait pu être source d'erreur.
Arf, bien sur, j'aurais du m'en douter. Merci pour la precision.
Malheureusement, ma fonction de génération de segments ne compile
plus, car je lui passe un output_iterator (en réalité un
back_inserter) en argument, qui a le mauvais goût d'avoir un
::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je
m'etais demandé pourquoi ce choix...
Je suppose que l'opérateur *() renvoit un objet proxy qui permet de
faire l'insertion. Dans ce cas, un value_type signifiant aurait pu être
source d'erreur.
Arf, bien sur, j'aurais du m'en douter. Merci pour la precision.
Malheureusement, ma fonction de génération de segments ne compile plus, car je lui passe un output_iterator (en réalité un back_inserter) en argument, qui a le mauvais goût d'avoir un ::value_type de type void, d'après le standard.
Ah, tiens, c'est vrai. Je me rappelle deja etre tombe dessus, et je m'etais demandé pourquoi ce choix...
Je suppose que l'opérateur *() renvoit un objet proxy qui permet de faire l'insertion. Dans ce cas, un value_type signifiant aurait pu être source d'erreur.
Arf, bien sur, j'aurais du m'en douter. Merci pour la precision.
