Bonjour,
Est ce que
#define min(A, B) (a < b ? a : b) (ou a peu près)
revient au même qu'une fonction inline (peut être en template ou
quelquechose comme ca ?)
inline template<struct T>
T min(const T& a, const T& b) {
if( a < b ) return a;
else return b;
Est ce que l'on restreint la portée du define si on l'enferme dans un
namespace?
--
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
On Fri, 31 Oct 2003 22:18:45 +0100, Benoit Rousseau wrote:
Est ce que l'on restreint la portée du define
On ne peut pas restreindre la portée d'un #define -- c'est pourquoi on en restreint l'usage au maximum.
-- ;-)
Loïc Joly
Benoit Rousseau wrote:
Bonjour, Est ce que #define min(A, B) (a < b ? a : b) (ou a peu près)
revient au même qu'une fonction inline (peut être en template ou quelquechose comme ca ?)
inline template<struct T> T min(const T& a, const T& b) { if( a < b ) return a; else return b;
Pas tout à fait : Dans le premier cas, min (i++, j) pourra produire des effets étranges (équivalent à (i++ < j ? i++ : j)). F'autres variantes tordues existent.
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas, ce qui n'est pas génial non plus (pour un template, le compilateur ne peut pas appliquer les conversions classiques aux arguments).
Est ce que l'on restreint la portée du define si on l'enferme dans un namespace?
Non :(
-- Loïc
Benoit Rousseau wrote:
Bonjour,
Est ce que
#define min(A, B) (a < b ? a : b) (ou a peu près)
revient au même qu'une fonction inline (peut être en template ou
quelquechose comme ca ?)
inline template<struct T>
T min(const T& a, const T& b) {
if( a < b ) return a;
else return b;
Pas tout à fait :
Dans le premier cas, min (i++, j) pourra produire des effets étranges
(équivalent à (i++ < j ? i++ : j)). F'autres variantes tordues existent.
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas,
ce qui n'est pas génial non plus (pour un template, le compilateur ne
peut pas appliquer les conversions classiques aux arguments).
Est ce que l'on restreint la portée du define si on l'enferme dans un
namespace?
Bonjour, Est ce que #define min(A, B) (a < b ? a : b) (ou a peu près)
revient au même qu'une fonction inline (peut être en template ou quelquechose comme ca ?)
inline template<struct T> T min(const T& a, const T& b) { if( a < b ) return a; else return b;
Pas tout à fait : Dans le premier cas, min (i++, j) pourra produire des effets étranges (équivalent à (i++ < j ? i++ : j)). F'autres variantes tordues existent.
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas, ce qui n'est pas génial non plus (pour un template, le compilateur ne peut pas appliquer les conversions classiques aux arguments).
Est ce que l'on restreint la portée du define si on l'enferme dans un namespace?
Non :(
-- Loïc
Fabien LE LEZ
On Sat, 01 Nov 2003 00:23:31 +0100, Loïc Joly wrote:
inline template<struct T> T min(const T& a, const T& b) {
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas, ce qui n'est pas génial non plus (pour un template, le compilateur ne peut pas appliquer les conversions classiques aux arguments).
J'ai fini par en avoir marre de cette restriction, et écrire mes propres fonctions :
template <class T, class T2> T Min (T const& a, T2 const& b) { if (a<b) return a; else return b; }
-- ;-)
On Sat, 01 Nov 2003 00:23:31 +0100, Loïc Joly
<loic.actarus.joly@wanadoo.fr> wrote:
inline template<struct T>
T min(const T& a, const T& b) {
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas,
ce qui n'est pas génial non plus (pour un template, le compilateur ne
peut pas appliquer les conversions classiques aux arguments).
J'ai fini par en avoir marre de cette restriction, et écrire mes
propres fonctions :
template <class T, class T2> T Min (T const& a, T2 const& b)
{
if (a<b) return a; else return b;
}
On Sat, 01 Nov 2003 00:23:31 +0100, Loïc Joly wrote:
inline template<struct T> T min(const T& a, const T& b) {
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas, ce qui n'est pas génial non plus (pour un template, le compilateur ne peut pas appliquer les conversions classiques aux arguments).
J'ai fini par en avoir marre de cette restriction, et écrire mes propres fonctions :
template <class T, class T2> T Min (T const& a, T2 const& b) { if (a<b) return a; else return b; }
-- ;-)
Benoit Rousseau
Loïc Joly wrote:
Benoit Rousseau wrote:
Bonjour, Est ce que #define min(A, B) (a < b ? a : b) (ou a peu près) correspond à template<T> inline T min( T&, T& )
Pas tout à fait : Dans le premier cas, min (i++, j) pourra produire des effets étranges (équivalent à (i++ < j ? i++ : j)). F'autres variantes tordues existent.
Oui, c'est un effet indésirable même... Mais je "purifie" un code déjà existant, alors j'essaie de retirer tout ce qui ne va pas
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas, ce qui n'est pas génial non plus (pour un template, le compilateur ne peut pas appliquer les conversions classiques aux arguments). Si il s'agit juste de choisir le type avant de lancer la fonction, ca
n'est pas un problème. Je comptais même l'utiliser en min<double>( (double)1, 2.3 ); Mais je me suis rendu compte que <double> n'était pas nécessaire...
Est ce que l'on restreint la portée du define si on l'enferme dans un namespace? Non :(
C'est vraiment nul alors... ils auraient pu penser à ça pour la "nouvelle" norme : les anciens #define n'auraient pas été affectés, et les nouveaux auraient pu être encapsulés...
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Loïc Joly wrote:
Benoit Rousseau wrote:
Bonjour,
Est ce que
#define min(A, B) (a < b ? a : b) (ou a peu près)
correspond à template<T> inline T min( T&, T& )
Pas tout à fait :
Dans le premier cas, min (i++, j) pourra produire des effets étranges
(équivalent à (i++ < j ? i++ : j)). F'autres variantes tordues existent.
Oui, c'est un effet indésirable même... Mais je "purifie" un code déjà
existant, alors j'essaie de retirer tout ce qui ne va pas
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas,
ce qui n'est pas génial non plus (pour un template, le compilateur ne
peut pas appliquer les conversions classiques aux arguments).
Si il s'agit juste de choisir le type avant de lancer la fonction, ca
n'est pas un problème.
Je comptais même l'utiliser en min<double>( (double)1, 2.3 );
Mais je me suis rendu compte que <double> n'était pas nécessaire...
Est ce que l'on restreint la portée du define si on l'enferme dans un
namespace?
Non :(
C'est vraiment nul alors... ils auraient pu penser à ça pour la
"nouvelle" norme : les anciens #define n'auraient pas été affectés, et
les nouveaux auraient pu être encapsulés...
--
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
Bonjour, Est ce que #define min(A, B) (a < b ? a : b) (ou a peu près) correspond à template<T> inline T min( T&, T& )
Pas tout à fait : Dans le premier cas, min (i++, j) pourra produire des effets étranges (équivalent à (i++ < j ? i++ : j)). F'autres variantes tordues existent.
Oui, c'est un effet indésirable même... Mais je "purifie" un code déjà existant, alors j'essaie de retirer tout ce qui ne va pas
D'un autre côté, avec la deuxième méthode, min(1, 2.3) ne marchera pas, ce qui n'est pas génial non plus (pour un template, le compilateur ne peut pas appliquer les conversions classiques aux arguments). Si il s'agit juste de choisir le type avant de lancer la fonction, ca
n'est pas un problème. Je comptais même l'utiliser en min<double>( (double)1, 2.3 ); Mais je me suis rendu compte que <double> n'était pas nécessaire...
Est ce que l'on restreint la portée du define si on l'enferme dans un namespace? Non :(
C'est vraiment nul alors... ils auraient pu penser à ça pour la "nouvelle" norme : les anciens #define n'auraient pas été affectés, et les nouveaux auraient pu être encapsulés...
-- -------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
Fabien LE LEZ
On Sat, 01 Nov 2003 10:27:47 +0100, Benoit Rousseau wrote:
Est ce que l'on restreint la portée du define si on l'enferme dans un namespace? Non :(
C'est vraiment nul alors... ils auraient pu penser à ça pour la "nouvelle" norme : les anciens #define n'auraient pas été affectés, et les nouveaux auraient pu être encapsulés...
De quels "nouveaux" parles-tu ? Le #define est traité par le préprocesseur, avant même que le compilateur proprement dit ne soit appelé. Et le préprocesseur ne connaît rien des namespaces. La solution est très simple : l'usage des #define est à réserver aux cas (assez rares) où on ne peut pas faire autrement.
-- ;-)
On Sat, 01 Nov 2003 10:27:47 +0100, Benoit Rousseau
<not.provided@no.spam> wrote:
Est ce que l'on restreint la portée du define si on l'enferme dans un
namespace?
Non :(
C'est vraiment nul alors... ils auraient pu penser à ça pour la
"nouvelle" norme : les anciens #define n'auraient pas été affectés, et
les nouveaux auraient pu être encapsulés...
De quels "nouveaux" parles-tu ?
Le #define est traité par le préprocesseur, avant même que le
compilateur proprement dit ne soit appelé. Et le préprocesseur ne
connaît rien des namespaces.
La solution est très simple : l'usage des #define est à réserver aux
cas (assez rares) où on ne peut pas faire autrement.
On Sat, 01 Nov 2003 10:27:47 +0100, Benoit Rousseau wrote:
Est ce que l'on restreint la portée du define si on l'enferme dans un namespace? Non :(
C'est vraiment nul alors... ils auraient pu penser à ça pour la "nouvelle" norme : les anciens #define n'auraient pas été affectés, et les nouveaux auraient pu être encapsulés...
De quels "nouveaux" parles-tu ? Le #define est traité par le préprocesseur, avant même que le compilateur proprement dit ne soit appelé. Et le préprocesseur ne connaît rien des namespaces. La solution est très simple : l'usage des #define est à réserver aux cas (assez rares) où on ne peut pas faire autrement.
