[HS] Vocabulaire

On 2008-01-01, Ph Ivaldi <piv_pasde@pub_tele2.fr> wrote:

Ma question est totalement hors sujet mais je sais qu'il y a ici des
personnes comp

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éant.

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.


[ rappel : suivi positionné vers fr.comp.lang.c++ ]

Cordialement,
--
Olivier Miakinen

Le nom correct d'un bloc de programme qu'on écrit est une fonction. Routine
et procédure pourraient être synonymes.

Une commande est un élément de base, inclus dans le langage. (if, while,
return, ...)

Ah, je voulais en parler mais j'ai oublié. Je nomme ces mots-clés (if,
while, return) plutôt des instructions du langage que des commandes.
Mais il faut reconnaître que c'est un peu ambigu car on appelle aussi
« instruction », par exemple, l'affectation « a = b = 5; ».

[ Suivi positionné vers fr.comp.lang.c++ ]

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++ ».

http://jargonf.org/wiki/Accueil

C'est marrant il n'y a pas routine. Mais en informatique ça a un sens,
bien évidemment. Une routine c'est une fonction ou une procédure. Une
procédure c'est une fonction qui ne retourne pas de valeur.


--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

Mickaël Wolff wrote on 02/01/2008 02:03:

[...]
une procédure c'est une fonction qui ne retourne pas de valeur.

en Pascal; cette distinction n'existe pas en C/C++.

Sylvain.

en Pascal; cette distinction n'existe pas en C/C++.

On peut considérer qu'un constructeur, un destructeur et une fonction
void toto(...) sont des procédures :) Et il n'y a pas qu'en Pascal...
Basic, Python, Perl, etc.

--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

On Tue, 01 Jan 2008 22:57:27 +0100, Olivier Miakinen
<om+news@miakinen.net>:

* 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.

En C++, oui. On emploie le mot "fonction", et pas "routine", ni
"procédure". Je crois me souvenir qu'en Pascal, on emploie le mot
"procédure".
Il me semble que toutes ces distinctions n'ont pas vraiment de sens à
l'intérieur d'un langage, mais plutôt dans un cadre théorique.

Note qu'en C++, une fonction a toujours un type de retour, même si le
type en question peut être "void".
En C K&R, le "void" n'existait pas, et une fonction renvoyait un int
par défaut.

Ah si, en C++ on peut appeler « méthodes » les fonctions attachées à une
classe.

On pourrait, mais ça ne décrit pas précisément de quoi on parle.
Il y a en C++ des fonctions membres, qui peuvent être virtuelles ou
pas. Comme pas mal de langages ne connaissent que les fonctions
membres virtuelles, le mot "méthode" désigne soit une fonction membre
virtuelle, soit plus généralement une fonction membre tout court,
selon les habitudes du locuteur. C'est pourquoi on n'emploie
généralement pas ce mot.

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". Il n'y a d'ailleurs pas de différence entre les deux, à part
les droits d'accès par défaut.

D'ailleurs, tu peux écrire :

struct C;

class C
{
...
};


De même, si tu spécifie explicitement les droits d'accès, tu peux
remplacer "class" par "struct" sans rien changer au programme :

class/struct C: public ClasseDeBase
{
public:
void f();
private:
void g();
};

Le mot "structure" étant hérité du C, il n'a pas de sens vraiment
précis en C++. Tantôt il désignera une classe à part entière
(éventuellement introduite par "struct"), tantôt il désignera une
classe dont la définition est acceptable par un compilateur C, i.e. ne
contenant que des variables membres publiques, et pas de fonctions
membres.


Le plus souvent, on emploie le mot "structure" pour la structure
générale du programme, et le mot "méthode" pour l'ensemble des
procédures à appliquer pour arriver à un but donné.

On Wed, 02 Jan 2008 02:22:53 +0100, Mickaël Wolff
<mickael.wolff@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(); }
};

Mais toto() est une fonction comme une autre, qui peut parfaitement
renvoyer une "valeur", de type "void".

Ça n'a aucun sens, d'autant plus qu'on ne peut pas exploité le retour.
Je suis d'ailleurs étonné que le compilateur accepte une telle écriture.

Dans le code suivant, f<int> est bien une fonction ; pourquoi
faudrait-il donner un nom différent ("procédure") à f<void> ?

C'est du chipotage, je n'utilise jamais non plus le terme de procédure.

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++.


--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

On Wed, 02 Jan 2008 08:17:44 +0100, Mickaël Wolff
<mickael.wolff@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 écriture.

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é.