Ma question est totalement hors sujet mais je sais qu'il y a ici des
personnes compétentes pour y répondre; me rediriger le cas échéant.
Dans un langage du type C++, quelles sont les différences (s'il y en a)
entre
1.
* une routine
(le mon anglais a-t-il le même sens en français ?)
* une fonction
* une procédure
* une commande
2.
* un paramètre
* un argument
3.
* une classe
* une structure
Ma question est totalement hors sujet mais je sais qu'il y a ici des
personnes compétentes pour y répondre; me rediriger le cas échéant.
Dans un langage du type C++, quelles sont les différences (s'il y en a)
entre
1.
* une routine
(le mon anglais a-t-il le même sens en français ?)
* une fonction
* une procédure
* une commande
2.
* un paramètre
* un argument
3.
* une classe
* une structure
Ma question est totalement hors sujet mais je sais qu'il y a ici des
personnes compétentes pour y répondre; me rediriger le cas échéant.
Dans un langage du type C++, quelles sont les différences (s'il y en a)
entre
1.
* une routine
(le mon anglais a-t-il le même sens en français ?)
* une fonction
* une procédure
* une commande
2.
* un paramètre
* un argument
3.
* une classe
* une structure
Qualifie de formel/actuel
Qualifie de formel/actuel
Qualifie de formel/actuel
Jean-Marc Bourguet wrote in message
:Qualifie de formel/actuel
Effectif serait une meilleure traduction de « actual ».
Jean-Marc Bourguet wrote in message
<pxb3atgk5f2.fsf@news.bourguet.org>:
Qualifie de formel/actuel
Effectif serait une meilleure traduction de « actual ».
Jean-Marc Bourguet wrote in message
:Qualifie de formel/actuel
Effectif serait une meilleure traduction de « actual ».
ATTENTION : Je suis loin d'être un expert en la matière, alors mes
réponses sont probablement sujettes à corrections ou amendements.Ma question est totalement hors sujet mais je sais qu'il y a ici des
personnes compétentes pour y répondre; me rediriger le cas échéa nt.
Je propose un suivi vers fr.comp.lang.c++ qui me semble assez adapté,
du moins si ta question concerne vraiment le C++ et pas l'ensemble des
langages « qui auraient des ressemblances (lesquelles ?) avec C++ ».
Dans un langage du type C++, quelles sont les différences (s'il y en a )
entre
1.
* une fonction
* une routine (le mon anglais a-t-il le même sens en français ?)
* une procédure
* une commande
Je ne pense pas qu'il y ait tant de types différents d'appels
à du code. Pour moi il n'y a que des fonctions. Il me semble
me souvenir que l'on parlait de procédures en BASIC. Une
commande est pour moi plutôt un exécutable (donc un programme
complet) qu'une fonction d'un langage donné. Quant à une «
routine » je n'ai pas l'impression que cela ait un sens
spécifique en informatique francophone. Pour un informaticien
comme pour n'importe qui d'autre, la routine, c'est un truc
habituel, voire répétitif.
Ah si, en C++ on peut appeler « méthodes » les fonctions
attachées à une classe.
2.
* un paramètre
* un argument
Personnellement je parle d'un paramètre pour une fonction, et
d'un argument pour une commande. Ainsi, les arguments d'une
commande Unix écrite en C ou en C++ peuvent être lus dans les
paramètres (souvent appelés argc et argv) de la fonction
main().
3.
* une classe
* une structure
En C, il n'y a que des structures, ne contenant que des
données, toutes d'accès public. En C++, je crois que
techniquement une classe est la même chose qu'une structure,
si ce n'est que l'accès par défaut est privé pour une classe
et public pour une structure. Mais habituellement on n'utilise
pas une structure pour ce qu'on fait avec des classes, à
savoir rassembler aussi des méthodes en plus des données.
ATTENTION : Je suis loin d'être un expert en la matière, alors mes
réponses sont probablement sujettes à corrections ou amendements.
Ma question est totalement hors sujet mais je sais qu'il y a ici des
personnes compétentes pour y répondre; me rediriger le cas échéa nt.
Je propose un suivi vers fr.comp.lang.c++ qui me semble assez adapté,
du moins si ta question concerne vraiment le C++ et pas l'ensemble des
langages « qui auraient des ressemblances (lesquelles ?) avec C++ ».
Dans un langage du type C++, quelles sont les différences (s'il y en a )
entre
1.
* une fonction
* une routine (le mon anglais a-t-il le même sens en français ?)
* une procédure
* une commande
Je ne pense pas qu'il y ait tant de types différents d'appels
à du code. Pour moi il n'y a que des fonctions. Il me semble
me souvenir que l'on parlait de procédures en BASIC. Une
commande est pour moi plutôt un exécutable (donc un programme
complet) qu'une fonction d'un langage donné. Quant à une «
routine » je n'ai pas l'impression que cela ait un sens
spécifique en informatique francophone. Pour un informaticien
comme pour n'importe qui d'autre, la routine, c'est un truc
habituel, voire répétitif.
Ah si, en C++ on peut appeler « méthodes » les fonctions
attachées à une classe.
2.
* un paramètre
* un argument
Personnellement je parle d'un paramètre pour une fonction, et
d'un argument pour une commande. Ainsi, les arguments d'une
commande Unix écrite en C ou en C++ peuvent être lus dans les
paramètres (souvent appelés argc et argv) de la fonction
main().
3.
* une classe
* une structure
En C, il n'y a que des structures, ne contenant que des
données, toutes d'accès public. En C++, je crois que
techniquement une classe est la même chose qu'une structure,
si ce n'est que l'accès par défaut est privé pour une classe
et public pour une structure. Mais habituellement on n'utilise
pas une structure pour ce qu'on fait avec des classes, à
savoir rassembler aussi des méthodes en plus des données.
ATTENTION : Je suis loin d'être un expert en la matière, alors mes
réponses sont probablement sujettes à corrections ou amendements.Ma question est totalement hors sujet mais je sais qu'il y a ici des
personnes compétentes pour y répondre; me rediriger le cas échéa nt.
Je propose un suivi vers fr.comp.lang.c++ qui me semble assez adapté,
du moins si ta question concerne vraiment le C++ et pas l'ensemble des
langages « qui auraient des ressemblances (lesquelles ?) avec C++ ».
Dans un langage du type C++, quelles sont les différences (s'il y en a )
entre
1.
* une fonction
* une routine (le mon anglais a-t-il le même sens en français ?)
* une procédure
* une commande
Je ne pense pas qu'il y ait tant de types différents d'appels
à du code. Pour moi il n'y a que des fonctions. Il me semble
me souvenir que l'on parlait de procédures en BASIC. Une
commande est pour moi plutôt un exécutable (donc un programme
complet) qu'une fonction d'un langage donné. Quant à une «
routine » je n'ai pas l'impression que cela ait un sens
spécifique en informatique francophone. Pour un informaticien
comme pour n'importe qui d'autre, la routine, c'est un truc
habituel, voire répétitif.
Ah si, en C++ on peut appeler « méthodes » les fonctions
attachées à une classe.
2.
* un paramètre
* un argument
Personnellement je parle d'un paramètre pour une fonction, et
d'un argument pour une commande. Ainsi, les arguments d'une
commande Unix écrite en C ou en C++ peuvent être lus dans les
paramètres (souvent appelés argc et argv) de la fonction
main().
3.
* une classe
* une structure
En C, il n'y a que des structures, ne contenant que des
données, toutes d'accès public. En C++, je crois que
techniquement une classe est la même chose qu'une structure,
si ce n'est que l'accès par défaut est privé pour une classe
et public pour une structure. Mais habituellement on n'utilise
pas une structure pour ce qu'on fait avec des classes, à
savoir rassembler aussi des méthodes en plus des données.
On Wed, 02 Jan 2008 02:22:53 +0100, Mickaël Wolff
:On peut considérer qu'un constructeur, un destructeur et une
fonction
void toto(...) sont des procédures :)
À la rigueur, l'implémentation en C++ du concept théorique de
"procédure".
Mais toto() est une fonction comme une autre, qui peut
parfaitement renvoyer une "valeur", de type "void".
Dans le code suivant, f<int> est bien une fonction ; pourquoi
faudrait-il donner un nom différent ("procédure") à f<void> ?
template <class T> T g() {}
template<> int g<int>() { return 0; }
template <class T> T f() { return g<T>(); }
void h() { return g<void>(); }
int main()
{
f<void>();
f<int>();
}
Pour le constructeur, j'ai un doute : Comeau et Borland C++
5.5 acceptent le code ci-dessus, mais g++ 4.1.2 le refuse.
struct C
{
C() { return h(); }
};
On Wed, 02 Jan 2008 02:22:53 +0100, Mickaël Wolff
<mickael.wo...@laposte.net>:
On peut considérer qu'un constructeur, un destructeur et une
fonction
void toto(...) sont des procédures :)
À la rigueur, l'implémentation en C++ du concept théorique de
"procédure".
Mais toto() est une fonction comme une autre, qui peut
parfaitement renvoyer une "valeur", de type "void".
Dans le code suivant, f<int> est bien une fonction ; pourquoi
faudrait-il donner un nom différent ("procédure") à f<void> ?
template <class T> T g() {}
template<> int g<int>() { return 0; }
template <class T> T f() { return g<T>(); }
void h() { return g<void>(); }
int main()
{
f<void>();
f<int>();
}
Pour le constructeur, j'ai un doute : Comeau et Borland C++
5.5 acceptent le code ci-dessus, mais g++ 4.1.2 le refuse.
struct C
{
C() { return h(); }
};
On Wed, 02 Jan 2008 02:22:53 +0100, Mickaël Wolff
:On peut considérer qu'un constructeur, un destructeur et une
fonction
void toto(...) sont des procédures :)
À la rigueur, l'implémentation en C++ du concept théorique de
"procédure".
Mais toto() est une fonction comme une autre, qui peut
parfaitement renvoyer une "valeur", de type "void".
Dans le code suivant, f<int> est bien une fonction ; pourquoi
faudrait-il donner un nom différent ("procédure") à f<void> ?
template <class T> T g() {}
template<> int g<int>() { return 0; }
template <class T> T f() { return g<T>(); }
void h() { return g<void>(); }
int main()
{
f<void>();
f<int>();
}
Pour le constructeur, j'ai un doute : Comeau et Borland C++
5.5 acceptent le code ci-dessus, mais g++ 4.1.2 le refuse.
struct C
{
C() { return h(); }
};
On Wed, 02 Jan 2008 08:17:44 +0100, Mickaël Wolff
:Mais toto() est une fonction comme une autre, qui peut
parfaitement renvoyer une "valeur", de type "void".
Ça n'a aucun sens
Une fonction qui retourne un int, renvoie un "objet" qui contient
(typiquement) 32 bits d'information.
Une fonction qui retourne void, renvoie un "objet" qui
contient 0 bit d'information.
C'est assez proche de la fonction ci-dessous :
class C {};
C f();
Je suis d'ailleurs étonné que le compilateur accepte une telle écri ture.
Il me semble que c'est récent.
Et j'en ai indiqué la raison dans mon code : c'est pour éviter
d'avoir à gérer les cas particuliers dans l'utilisation de
templates.
template <class T> class C
{
public:
bool OK() const;
T f() { assert (OK()); return g(); }
private:
T g();
};struct C
{
C() { return h(); }
};
Je ne sais pas ce que la norme dit à ce propos. Mais ça me
parait spécieux qu'un compilateur puisse accepter cette
écriture, du moins en C++.
J'avoue avoir été étonné que Comeau l'accepte. Dans le cas des
constructeurs et destructeurs, il est vrai que cette écriture
n'a guère de légitimité.
On Wed, 02 Jan 2008 08:17:44 +0100, Mickaël Wolff
<mickael.wo...@laposte.net>:
Mais toto() est une fonction comme une autre, qui peut
parfaitement renvoyer une "valeur", de type "void".
Ça n'a aucun sens
Une fonction qui retourne un int, renvoie un "objet" qui contient
(typiquement) 32 bits d'information.
Une fonction qui retourne void, renvoie un "objet" qui
contient 0 bit d'information.
C'est assez proche de la fonction ci-dessous :
class C {};
C f();
Je suis d'ailleurs étonné que le compilateur accepte une telle écri ture.
Il me semble que c'est récent.
Et j'en ai indiqué la raison dans mon code : c'est pour éviter
d'avoir à gérer les cas particuliers dans l'utilisation de
templates.
template <class T> class C
{
public:
bool OK() const;
T f() { assert (OK()); return g(); }
private:
T g();
};
struct C
{
C() { return h(); }
};
Je ne sais pas ce que la norme dit à ce propos. Mais ça me
parait spécieux qu'un compilateur puisse accepter cette
écriture, du moins en C++.
J'avoue avoir été étonné que Comeau l'accepte. Dans le cas des
constructeurs et destructeurs, il est vrai que cette écriture
n'a guère de légitimité.
On Wed, 02 Jan 2008 08:17:44 +0100, Mickaël Wolff
:Mais toto() est une fonction comme une autre, qui peut
parfaitement renvoyer une "valeur", de type "void".
Ça n'a aucun sens
Une fonction qui retourne un int, renvoie un "objet" qui contient
(typiquement) 32 bits d'information.
Une fonction qui retourne void, renvoie un "objet" qui
contient 0 bit d'information.
C'est assez proche de la fonction ci-dessous :
class C {};
C f();
Je suis d'ailleurs étonné que le compilateur accepte une telle écri ture.
Il me semble que c'est récent.
Et j'en ai indiqué la raison dans mon code : c'est pour éviter
d'avoir à gérer les cas particuliers dans l'utilisation de
templates.
template <class T> class C
{
public:
bool OK() const;
T f() { assert (OK()); return g(); }
private:
T g();
};struct C
{
C() { return h(); }
};
Je ne sais pas ce que la norme dit à ce propos. Mais ça me
parait spécieux qu'un compilateur puisse accepter cette
écriture, du moins en C++.
J'avoue avoir été étonné que Comeau l'accepte. Dans le cas des
constructeurs et destructeurs, il est vrai que cette écriture
n'a guère de légitimité.
En C++, je crois que techniquement une classe est la
même chose qu'une structure, si ce n'est que l'accès par défaut est
privé pour une classe et public pour une structure.
C'est plus flou que ça. Le terme "classe" désigne tout ce qui
est introduit par "struct" et "class".
Le mot "structure" étant hérité du C, il n'a pas de sens
vraiment précis en C++.
En C++, je crois que techniquement une classe est la
même chose qu'une structure, si ce n'est que l'accès par défaut est
privé pour une classe et public pour une structure.
C'est plus flou que ça. Le terme "classe" désigne tout ce qui
est introduit par "struct" et "class".
Le mot "structure" étant hérité du C, il n'a pas de sens
vraiment précis en C++.
En C++, je crois que techniquement une classe est la
même chose qu'une structure, si ce n'est que l'accès par défaut est
privé pour une classe et public pour une structure.
C'est plus flou que ça. Le terme "classe" désigne tout ce qui
est introduit par "struct" et "class".
Le mot "structure" étant hérité du C, il n'a pas de sens
vraiment précis en C++.
Sérieusement : void, en tant que type de
rétour, est un peu spécial
Sérieusement : void, en tant que type de
rétour, est un peu spécial
Sérieusement : void, en tant que type de
rétour, est un peu spécial
Dans l'utilisation de tous les jours (en dehors de
la norme, donc), je crois que la plupart des gens ne comprenent
pas des unions quand on parle des classes.
Dans l'utilisation de tous les jours (en dehors de
la norme, donc), je crois que la plupart des gens ne comprenent
pas des unions quand on parle des classes.
Dans l'utilisation de tous les jours (en dehors de
la norme, donc), je crois que la plupart des gens ne comprenent
pas des unions quand on parle des classes.
Dans l'utilisation de tous les jours (en dehors de
la norme, donc), je crois que la plupart des gens ne comprenent
pas des unions quand on parle des classes.
Faut dire aussi que dans l'utilisation de tous les jours, on ne
rencontre pas très souvent "union".
Dans l'utilisation de tous les jours (en dehors de
la norme, donc), je crois que la plupart des gens ne comprenent
pas des unions quand on parle des classes.
Faut dire aussi que dans l'utilisation de tous les jours, on ne
rencontre pas très souvent "union".
Dans l'utilisation de tous les jours (en dehors de
la norme, donc), je crois que la plupart des gens ne comprenent
pas des unions quand on parle des classes.
Faut dire aussi que dans l'utilisation de tous les jours, on ne
rencontre pas très souvent "union".