1) Est ce que c'est, d'apres vous, une "bonne" facon de faire?
2) Si oui (mais je pense que non), j'ai un pb:
ABSOLUTE est deja declaree comme constantes dans certains headers ce qui
donne apres le preproceseur:
enum MON_ENUM
{
1 = 0,
SEMI_RELATIVE = 1,
RELATIVE = 2
};
ce qui ne marche pas forcement tres bien..;-)
Qq1 parmi vous aurait il un conseil pour eviter ce genre de problemes?
En esperant que ma question ne soit pas trop con...
|> >C-à-d celles qui vont être initialisées à partir d'un |> >fichier de configuration dans la prochaine version ?
|> Si jamais ça arrive (dans mon code), il y a des chances pour que |> la "constante" soit alors modifiable en cours d'exécution (GUI |> oblige). Du coup, ça devient une variable globale, que je |> transforme généralement en appel de fonction. Du coup, il y a |> des modifications à faire de toutes façons ;-)
Ça dépend. En partie, tu as probablement raison -- si j'utilise un fichier de configuration je passe prèsqu'automatiquement par un singleton ConfigurationManager. Ce n'est pas le cas pour des options de la ligne de commande, en revanche, et si j'avais à modifier une constante existante, je pourrais imaginer justement que je m'arrange pour qu'elle soit une variable globale, de façon à ne pas obliger des modifications partout.
|> En fait, j'utilise plutôt des constantes en majuscules à |> visibilité réduire à une fonction, et les majuscules m'aide |> à savoir que l'objet gardera la même valeur jusqu'à la fin |> de la fonction.
Intéressant. Ce n'est pas une convention que j'ai vue jusqu'ici. C'est d'ailleurs pourquoi j'ai posé la question à Michel, parce que toujours, quand j'ai vu cette convention, elle ne s'appliquait que pour des constantes globales, jamais des constantes locales.
-- James Kanze mailto: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
Fabien LE LEZ <gramster@gramster.com> writes:
|> On 17 Oct 2003 07:55:28 -0700, kanze@gabi-soft.fr wrote:
|> >C-à-d celles qui vont être initialisées à partir d'un
|> >fichier de configuration dans la prochaine version ?
|> Si jamais ça arrive (dans mon code), il y a des chances pour que
|> la "constante" soit alors modifiable en cours d'exécution (GUI
|> oblige). Du coup, ça devient une variable globale, que je
|> transforme généralement en appel de fonction. Du coup, il y a
|> des modifications à faire de toutes façons ;-)
Ça dépend. En partie, tu as probablement raison -- si j'utilise un
fichier de configuration je passe prèsqu'automatiquement par un
singleton ConfigurationManager. Ce n'est pas le cas pour des options de
la ligne de commande, en revanche, et si j'avais à modifier une
constante existante, je pourrais imaginer justement que je m'arrange
pour qu'elle soit une variable globale, de façon à ne pas obliger
des modifications partout.
|> En fait, j'utilise plutôt des constantes en majuscules à
|> visibilité réduire à une fonction, et les majuscules m'aide
|> à savoir que l'objet gardera la même valeur jusqu'à la fin
|> de la fonction.
Intéressant. Ce n'est pas une convention que j'ai vue jusqu'ici.
C'est d'ailleurs pourquoi j'ai posé la question à Michel, parce
que toujours, quand j'ai vu cette convention, elle ne s'appliquait que
pour des constantes globales, jamais des constantes locales.
--
James Kanze mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
|> >C-à-d celles qui vont être initialisées à partir d'un |> >fichier de configuration dans la prochaine version ?
|> Si jamais ça arrive (dans mon code), il y a des chances pour que |> la "constante" soit alors modifiable en cours d'exécution (GUI |> oblige). Du coup, ça devient une variable globale, que je |> transforme généralement en appel de fonction. Du coup, il y a |> des modifications à faire de toutes façons ;-)
Ça dépend. En partie, tu as probablement raison -- si j'utilise un fichier de configuration je passe prèsqu'automatiquement par un singleton ConfigurationManager. Ce n'est pas le cas pour des options de la ligne de commande, en revanche, et si j'avais à modifier une constante existante, je pourrais imaginer justement que je m'arrange pour qu'elle soit une variable globale, de façon à ne pas obliger des modifications partout.
|> En fait, j'utilise plutôt des constantes en majuscules à |> visibilité réduire à une fonction, et les majuscules m'aide |> à savoir que l'objet gardera la même valeur jusqu'à la fin |> de la fonction.
Intéressant. Ce n'est pas une convention que j'ai vue jusqu'ici. C'est d'ailleurs pourquoi j'ai posé la question à Michel, parce que toujours, quand j'ai vu cette convention, elle ne s'appliquait que pour des constantes globales, jamais des constantes locales.
-- James Kanze mailto: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
Fabien LE LEZ
On 19 Oct 2003 17:11:43 +0200, James Kanze wrote:
toujours, quand j'ai vu cette convention, elle ne s'appliquait que pour des constantes globales, jamais des constantes locales.
En fait, j'utilise principalement les constantes globales (en majuscules aussi, du coup) dans les cas où il faut vraiment une constante (paramètre de template, tableau à la C, fichiers .rc de Windows...) -- http://www.giromini.org/usenet-fr/repondre.html
On 19 Oct 2003 17:11:43 +0200, James Kanze <kanze@alex.gabi-soft.fr>
wrote:
toujours, quand j'ai vu cette convention, elle ne s'appliquait que
pour des constantes globales, jamais des constantes locales.
En fait, j'utilise principalement les constantes globales (en
majuscules aussi, du coup) dans les cas où il faut vraiment une
constante (paramètre de template, tableau à la C, fichiers .rc de
Windows...)
--
http://www.giromini.org/usenet-fr/repondre.html
toujours, quand j'ai vu cette convention, elle ne s'appliquait que pour des constantes globales, jamais des constantes locales.
En fait, j'utilise principalement les constantes globales (en majuscules aussi, du coup) dans les cas où il faut vraiment une constante (paramètre de template, tableau à la C, fichiers .rc de Windows...) -- http://www.giromini.org/usenet-fr/repondre.html
Michel Michaud
Dans news:, Fabien LE
Ben justement, un identificateur vraiment significatif devrait indiquer clairement le rôle de la variable, et du coup sa const-ness serait évidente pour le lecteur... dans l'idéal, bien sûr ;-)
Ben justement, en utilisant les majuscules pour dire « constante ! » l'identificateur devient encore plus significatif...
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:n6vuovcor79eirmet6msekbmpe2tdrn3dl@4ax.com, Fabien LE
Ben justement, un identificateur vraiment significatif devrait
indiquer clairement le rôle de la variable, et du coup sa const-ness
serait évidente pour le lecteur... dans l'idéal, bien sûr ;-)
Ben justement, en utilisant les majuscules pour dire « constante ! »
l'identificateur devient encore plus significatif...
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Ben justement, un identificateur vraiment significatif devrait indiquer clairement le rôle de la variable, et du coup sa const-ness serait évidente pour le lecteur... dans l'idéal, bien sûr ;-)
Ben justement, en utilisant les majuscules pour dire « constante ! » l'identificateur devient encore plus significatif...
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Jean-Marc Molina
Bonsoir,
Le nom peut être porteur du type : pi = constante PI (float) : const float pi = 3.14 ...
Après on peut utiliser des préfixes/suffixes "à la sauce MS"/Hongroise : fPI ou PI_CONST...
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES. C'est un peu devenu un standard il me semble. On utilise généralement une constante/define comme une valeur, ça met alors le nom à l'échelle des chiffes : PI * 180, pi * 180, fPI * 180...
C'est homogène voir presque beau :)
Bonne soirée, JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Bonsoir,
Le nom peut être porteur du type :
pi = constante PI (float) : const float pi = 3.14
...
Après on peut utiliser des préfixes/suffixes "à la sauce MS"/Hongroise : fPI
ou PI_CONST...
En C++ il faut quand même prendre en considération que la majorité des
constantes sont en MAJUSCULES.
C'est un peu devenu un standard il me semble. On utilise généralement une
constante/define comme une valeur, ça met alors le nom à l'échelle des
chiffes : PI * 180, pi * 180, fPI * 180...
C'est homogène voir presque beau :)
Bonne soirée,
JM
--
Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Le nom peut être porteur du type : pi = constante PI (float) : const float pi = 3.14 ...
Après on peut utiliser des préfixes/suffixes "à la sauce MS"/Hongroise : fPI ou PI_CONST...
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES. C'est un peu devenu un standard il me semble. On utilise généralement une constante/define comme une valeur, ça met alors le nom à l'échelle des chiffes : PI * 180, pi * 180, fPI * 180...
C'est homogène voir presque beau :)
Bonne soirée, JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Jean-Marc Bourguet
"Jean-Marc Molina" writes:
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
En C++ il faut quand même prendre en considération que la majorité des
constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel.
Je vois plus de code ou les nom tout en majuscules sont reserves au
preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il
y ait une convention pour les constantes, mais je prefere qu'elle soit
differente de celle pour les identificateurs du preprocesseur)
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Michel Michaud
Dans news:, Jean-Marc
"Jean-Marc Molina" writes:
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes. Je n'aurais rien contre c_xyz ou autre, mais la convention classique dans C, Java et même pour beaucoup en C++ étant les majuscules, ce n'est pas complètement mauvais de l'utiliser surtout si on n'utilise jamais les macros... Je sais, il y en a quand même, mais on fait avec. D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:pxb65ii8s36.fsf@news.bourguet.org, Jean-Marc
En C++ il faut quand même prendre en considération que la majorité
des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre
universel. Je vois plus de code ou les nom tout en majuscules sont
reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me
derange pas qu'il
y ait une convention pour les constantes, mais je prefere qu'elle
soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes.
Je n'aurais rien contre c_xyz ou autre, mais la convention classique
dans C, Java et même pour beaucoup en C++ étant les majuscules, ce
n'est pas complètement mauvais de l'utiliser surtout si on n'utilise
jamais les macros... Je sais, il y en a quand même, mais on fait avec.
D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes. Je n'aurais rien contre c_xyz ou autre, mais la convention classique dans C, Java et même pour beaucoup en C++ étant les majuscules, ce n'est pas complètement mauvais de l'utiliser surtout si on n'utilise jamais les macros... Je sais, il y en a quand même, mais on fait avec. D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Fabien LE LEZ
On Tue, 21 Oct 2003 21:02:50 -0400, "Michel Michaud" wrote:
surtout si on n'utilise jamais les macros...
Et donc si on n'utilise pas l'API Windows, qui en contient un nombre affolant (pas forcément toutes en majuscules, d'ailleurs) :-(
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes. Je n'aurais rien contre c_xyz ou autre, mais la convention classique dans C,
En C les problemes de portees sont differents et beaucoup plus simples qu'en C++. Et le code que j'ai sous les yeux -- et dont la redaction remonte au moins au debut des annees 90 -- utilise bien (en partie -- il est trop vieux et trop le resultat d'aggregation pour etre homogene) la convention tout en majuscule pour les macros et un c pour les constantes (apres le prefixe de groupe).
Java
Java n'a pas de preprocesseur... ce qui le rend totalement non pertinent pour la dicussion en cours.
et même pour beaucoup en C++ étant les majuscules, ce n'est pas complètement mauvais de l'utiliser surtout si on n'utilise jamais les macros...
Ce n'est pas les macros que tu utilises qui posent probleme, c'est celles que tu n'utilises pas, dont tu ne connaissais meme pas l'existance mais qui sont maintenant importee par effet de bord (tu utilises en en-tete qui est modifie pour inclure un autre entete qui provient de la derniere boite qui a ete achetee et dont le code est en C pur donc avec macros... tu n'utilises pas ce code mais il y a un clash entre le nom d'une de celles-ci et un symbole a toi qui est une constante tout en majuscules -- eh oui ta constante est definie avant d'inclure le fichier et donc il n'y a pas de probleme de compilation).
Je sais, il y en a quand même, mais on fait avec. D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
Les symboles definis par l'implementation, on y touche pas et l'implementation fait ce qu'elle veut.
Je ne vois toujours pas d'avantage a avoir la meme convention pour les macros et les constantes (jusqu'a present la seule justification que j'ai entendu c'est que c'est une convention existante, ce qui est faible). J'en ai vecu les inconveniants.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
"Michel Michaud" <mm@gdzid.com> writes:
Dans news:pxb65ii8s36.fsf@news.bourguet.org, Jean-Marc
En C++ il faut quand même prendre en considération que la majorité
des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre
universel. Je vois plus de code ou les nom tout en majuscules sont
reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me
derange pas qu'il
y ait une convention pour les constantes, mais je prefere qu'elle
soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes.
Je n'aurais rien contre c_xyz ou autre, mais la convention classique
dans C,
En C les problemes de portees sont differents et beaucoup plus simples
qu'en C++. Et le code que j'ai sous les yeux -- et dont la redaction
remonte au moins au debut des annees 90 -- utilise bien (en partie --
il est trop vieux et trop le resultat d'aggregation pour etre
homogene) la convention tout en majuscule pour les macros et un c pour
les constantes (apres le prefixe de groupe).
Java
Java n'a pas de preprocesseur... ce qui le rend totalement non
pertinent pour la dicussion en cours.
et même pour beaucoup en C++ étant les majuscules, ce n'est pas
complètement mauvais de l'utiliser surtout si on n'utilise jamais
les macros...
Ce n'est pas les macros que tu utilises qui posent probleme, c'est
celles que tu n'utilises pas, dont tu ne connaissais meme pas
l'existance mais qui sont maintenant importee par effet de bord (tu
utilises en en-tete qui est modifie pour inclure un autre entete qui
provient de la derniere boite qui a ete achetee et dont le code est en
C pur donc avec macros... tu n'utilises pas ce code mais il y a un
clash entre le nom d'une de celles-ci et un symbole a toi qui est une
constante tout en majuscules -- eh oui ta constante est definie avant
d'inclure le fichier et donc il n'y a pas de probleme de compilation).
Je sais, il y en a quand même, mais on fait avec.
D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
Les symboles definis par l'implementation, on y touche pas et
l'implementation fait ce qu'elle veut.
Je ne vois toujours pas d'avantage a avoir la meme convention pour les
macros et les constantes (jusqu'a present la seule justification que
j'ai entendu c'est que c'est une convention existante, ce qui est
faible). J'en ai vecu les inconveniants.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes. Je n'aurais rien contre c_xyz ou autre, mais la convention classique dans C,
En C les problemes de portees sont differents et beaucoup plus simples qu'en C++. Et le code que j'ai sous les yeux -- et dont la redaction remonte au moins au debut des annees 90 -- utilise bien (en partie -- il est trop vieux et trop le resultat d'aggregation pour etre homogene) la convention tout en majuscule pour les macros et un c pour les constantes (apres le prefixe de groupe).
Java
Java n'a pas de preprocesseur... ce qui le rend totalement non pertinent pour la dicussion en cours.
et même pour beaucoup en C++ étant les majuscules, ce n'est pas complètement mauvais de l'utiliser surtout si on n'utilise jamais les macros...
Ce n'est pas les macros que tu utilises qui posent probleme, c'est celles que tu n'utilises pas, dont tu ne connaissais meme pas l'existance mais qui sont maintenant importee par effet de bord (tu utilises en en-tete qui est modifie pour inclure un autre entete qui provient de la derniere boite qui a ete achetee et dont le code est en C pur donc avec macros... tu n'utilises pas ce code mais il y a un clash entre le nom d'une de celles-ci et un symbole a toi qui est une constante tout en majuscules -- eh oui ta constante est definie avant d'inclure le fichier et donc il n'y a pas de probleme de compilation).
Je sais, il y en a quand même, mais on fait avec. D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
Les symboles definis par l'implementation, on y touche pas et l'implementation fait ce qu'elle veut.
Je ne vois toujours pas d'avantage a avoir la meme convention pour les macros et les constantes (jusqu'a present la seule justification que j'ai entendu c'est que c'est une convention existante, ce qui est faible). J'en ai vecu les inconveniants.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
kanze
"Jean-Marc Molina" wrote in message news:<bn3mdc$u2g$...
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
Tu pourrais m'en donner des exemples. Parce qu'en dehors de celles héritées de C (mais qui se sert de FILE), je n'en vois pas. Compare FLT_MANT_DIG avec std::numeric_limits<float>::digits, etc.
C'est un peu devenu un standard il me semble.
C'était un standard en C, probablement parce qu'en C, de telles constantes étaient des macros, qui n'obéissaient pas aux régles de portées, etc.
On utilise généralement une constante/define comme une valeur, ça met alors le nom à l'échelle des chiffes : PI * 180, pi * 180, fPI * 180...
C'est homogène voir presque beau :)
Je ne comprends pas trop ce que tu essaies à dire là. Tu veux dire comme : 2 * pi * r ? Mais quoi ?
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Jean-Marc Molina" <goa_pasdepourriel_@ifrance.com> wrote in message
news:<bn3mdc$u2g$1@news-reader1.wanadoo.fr>...
En C++ il faut quand même prendre en considération que la majorité des
constantes sont en MAJUSCULES.
Tu pourrais m'en donner des exemples. Parce qu'en dehors de celles
héritées de C (mais qui se sert de FILE), je n'en vois pas. Compare
FLT_MANT_DIG avec std::numeric_limits<float>::digits, etc.
C'est un peu devenu un standard il me semble.
C'était un standard en C, probablement parce qu'en C, de telles
constantes étaient des macros, qui n'obéissaient pas aux régles de
portées, etc.
On utilise généralement une constante/define comme une valeur, ça met
alors le nom à l'échelle des chiffes : PI * 180, pi * 180, fPI *
180...
C'est homogène voir presque beau :)
Je ne comprends pas trop ce que tu essaies à dire là. Tu veux dire
comme : 2 * pi * r ? Mais quoi ?
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Jean-Marc Molina" wrote in message news:<bn3mdc$u2g$...
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
Tu pourrais m'en donner des exemples. Parce qu'en dehors de celles héritées de C (mais qui se sert de FILE), je n'en vois pas. Compare FLT_MANT_DIG avec std::numeric_limits<float>::digits, etc.
C'est un peu devenu un standard il me semble.
C'était un standard en C, probablement parce qu'en C, de telles constantes étaient des macros, qui n'obéissaient pas aux régles de portées, etc.
On utilise généralement une constante/define comme une valeur, ça met alors le nom à l'échelle des chiffes : PI * 180, pi * 180, fPI * 180...
C'est homogène voir presque beau :)
Je ne comprends pas trop ce que tu essaies à dire là. Tu veux dire comme : 2 * pi * r ? Mais quoi ?
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
kanze
"Michel Michaud" wrote in message news:<0Hklb.2025$...
Dans news:, Jean-Marc
"Jean-Marc Molina" writes:
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes. Je n'aurais rien contre c_xyz ou autre, mais la convention classique dans C, Java et même pour beaucoup en C++ étant les majuscules, ce n'est pas complètement mauvais de l'utiliser surtout si on n'utilise jamais les macros... Je sais, il y en a quand même, mais on fait avec. D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
Ah, l'histoire:-). Quand j'ai commencé en C et Unix, errno était simplement : extern int errno ; En revanche, il y a toujours eu des macros fonctionnelles non-majuscules : getchar, getc, assert...
Le problème, c'est comme a dit Jean-Marc, distinguer les macros serait plus important que distinguer les constantes. Et si on a effectivement des contradictions (et pour les macros, et pour les constantes), il y a bien une convention encore plus répandue que pour les constantes que les macros s'écrivent tout en majuscule (FILE, mais aussi FLT_DIG, qui donne std::numeric_limits< float >::digits en C++).
Dans la pratique, dans le type d'applications sur lesquelles j'ai travaillé jusqu'ici, je n'ai pas vu la nécessité de distinguer les constantes. Peut-être en partie parce que les constantes ne le sont pas toujours, au fur et à mésure que le programme évolve. Donc, je ne les distingue pas.
Mais c'est basé sur mon expérience, et je n'exclurais pas la possibilité que dans d'autres domaines, la distinction ait de l'importance.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Michel Michaud" <mm@gdzid.com> wrote in message
news:<0Hklb.2025$VQ3.274223@news20.bellglobal.com>...
Dans news:pxb65ii8s36.fsf@news.bourguet.org, Jean-Marc
En C++ il faut quand même prendre en considération que la majorité
des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre
universel. Je vois plus de code ou les nom tout en majuscules sont
reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me
derange pas qu'il y ait une convention pour les constantes, mais je
prefere qu'elle soit differente de celle pour les identificateurs du
preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes.
Je n'aurais rien contre c_xyz ou autre, mais la convention classique
dans C, Java et même pour beaucoup en C++ étant les majuscules, ce
n'est pas complètement mauvais de l'utiliser surtout si on n'utilise
jamais les macros... Je sais, il y en a quand même, mais on fait avec.
D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
Ah, l'histoire:-). Quand j'ai commencé en C et Unix, errno était
simplement :
extern int errno ;
En revanche, il y a toujours eu des macros fonctionnelles
non-majuscules : getchar, getc, assert...
Le problème, c'est comme a dit Jean-Marc, distinguer les macros serait
plus important que distinguer les constantes. Et si on a effectivement
des contradictions (et pour les macros, et pour les constantes), il y a
bien une convention encore plus répandue que pour les constantes que les
macros s'écrivent tout en majuscule (FILE, mais aussi FLT_DIG, qui donne
std::numeric_limits< float >::digits en C++).
Dans la pratique, dans le type d'applications sur lesquelles j'ai
travaillé jusqu'ici, je n'ai pas vu la nécessité de distinguer les
constantes. Peut-être en partie parce que les constantes ne le sont pas
toujours, au fur et à mésure que le programme évolve. Donc, je ne les
distingue pas.
Mais c'est basé sur mon expérience, et je n'exclurais pas la possibilité
que dans d'autres domaines, la distinction ait de l'importance.
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Michel Michaud" wrote in message news:<0Hklb.2025$...
Dans news:, Jean-Marc
"Jean-Marc Molina" writes:
En C++ il faut quand même prendre en considération que la majorité des constantes sont en MAJUSCULES.
A nouveau (voir les autres threads), c'est tres loin d'etre universel. Je vois plus de code ou les nom tout en majuscules sont reserves au preprocesseur (et ca m'a l'air plus sense, ca ne me derange pas qu'il y ait une convention pour les constantes, mais je prefere qu'elle soit differente de celle pour les identificateurs du preprocesseur)
L'idée est effectivement d'avoir une convention pour les constantes. Je n'aurais rien contre c_xyz ou autre, mais la convention classique dans C, Java et même pour beaucoup en C++ étant les majuscules, ce n'est pas complètement mauvais de l'utiliser surtout si on n'utilise jamais les macros... Je sais, il y en a quand même, mais on fait avec. D'ailleurs on a quoi... « errno » ?! Ah ces majuscules :-).
Ah, l'histoire:-). Quand j'ai commencé en C et Unix, errno était simplement : extern int errno ; En revanche, il y a toujours eu des macros fonctionnelles non-majuscules : getchar, getc, assert...
Le problème, c'est comme a dit Jean-Marc, distinguer les macros serait plus important que distinguer les constantes. Et si on a effectivement des contradictions (et pour les macros, et pour les constantes), il y a bien une convention encore plus répandue que pour les constantes que les macros s'écrivent tout en majuscule (FILE, mais aussi FLT_DIG, qui donne std::numeric_limits< float >::digits en C++).
Dans la pratique, dans le type d'applications sur lesquelles j'ai travaillé jusqu'ici, je n'ai pas vu la nécessité de distinguer les constantes. Peut-être en partie parce que les constantes ne le sont pas toujours, au fur et à mésure que le programme évolve. Donc, je ne les distingue pas.
Mais c'est basé sur mon expérience, et je n'exclurais pas la possibilité que dans d'autres domaines, la distinction ait de l'importance.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
