Interet du type & nomfonction(.. - Page 1

perso j'en vois pas trop si ce n'est faire des choses comme ma_fonction()=3.
??? non serieux ca sert bcp

De quoi tu parles ?

Je pense que c'est censé être dans "Prog C++ PC"...

Pour répondre à ta question si c'est bien du C++, oui ça sert : tu peux choisir, par exemple, d'utiliser autant de références que possible dans ton prog et d'éviter les pointeurs. Les références te donnent à la fois la certitude que l'adresse de l'objet ne sera pas modifiée, et en plus tu es sûr que c'est bien valide. Par exemple, si tu avais une classe ModeSettings, et si tu as une fonction qui s'appelle GetCurrentMode(), elle peut renvoyer un ModeSettings&, comme ça tu peux faire GetCurrentMode().angle=ModeSettings::radians ... On peut contester l'utilité des références dans ce genre de cas simple, mais c'est important pour la cohérence du langage si tu veux avoir des conversions automatiques, des opérateurs redéfinis du style -> ou [] (par exemple, renvoyer un vector& permet une utilisation moins "lourde" que renvoyer un vector* : GetTable()[i++]=read() est bien plus simple que (*GetTable())[i++]=read(), et je ne parle même pas de ce qui se passe si tu as plusieurs niveaux d'imbrications, parce que tu auras des parenthèses et des * dans tous les sens).

Oui, c'est bien du C++ enfin, faut voir avec l'iso c99 on sait jamais

nEUrOO :
Oui, c'est bien du C++ enfin, faut voir avec l'iso c99 on sait jamais

Non, il n'y a pas les références dans le C99. Peut-être dans le C 2009.

Beurk, j'en veux pas.

Pourquoi ?
ça change quoi par rapport au passage par adresse, si ce n'est que le code devient plus lisible ?
Peut-être que ça peut être une source d'erreur si on oublie que le paramètre est passé par référence...

Voilà.

Bah, sans ça, tout le monde met (en tout cas, moi, j'utilise régulièrement ça, et je ne pense pas être le seul):
#define mafonction(ref) mafonction_(&ref)

void mafonction_(type *p_toto)
{
#define toto (*p_toto)
...
#undef toto
}
et ce n'est pas mieux.

Pkoi ne pas travailler avec les ptrs directement ? Ou est le mal ?

C'est plus simple à écrire.

C'est surtout source de bugs...

Je n'ai pas encore eu de bug lié au passage par référence dans GTC 2.0, pourtant j'en fais tout le tps (des passages par référence) et le moins qu'on puisse dire, c'est que j'ai pas une énorme expérience du C++... En plus avec une IDE correcte les types des paramètres s'affichent qd tu appelles une fonction, et en particulier s'ils sont passés par référence ou par valeur.

C'est une maniere sale de repondre au probleme de renvoyer plusieurs parametres.

Je ne parle pas de renvoyer plusieurs paramètres, d'ailleurs c'est loin d'être son utilité principale. Je considère ça plutôt comme un remplacement du "struct machin *" qu'on doit passer en paramètre : le fait de passer un "struct machin &" permet une syntaxe bien plus légère et logique, et, comme je l'ai déjà dit plus haut, facilite les conversions de type.

Pour renvoyer plusieurs paramètres, en C++ la solution propre est de renvoyer un pair<int,int>

En quoi elle est plus simple et plus logique ?

Plus simple?

vector<int> Xor(vector<int>& a,vector<int>& b) {
  if (a.size()!=b.size())
    throw "Mismatching dimensions";
  vector<int> c;
  for (int i=0;i<a.size();i++)
    c.push_back(a[i]^b[i]);
  return c;
}

Plus logique? Dans cette fonction, a, b et c jouent le même rôle. Par exemple, je pourrais vouloir faire un test portant sur Add(a,c) et Add(b,c). Avec la syntaxe C-like (vector<int>* a,vector<int> *b), je serais obligé d'utiliser Add(a,&c) et Add(b,&c) : c'est ridicule, a, b et c sont tous les trois des tableaux, la seule différence est que l'un est un paramètre et l'autre une variable locale.

On peut en profiter pour n'utiliser que * et -> que quand on a un objet dont l'adresse peut varier, et pas dans les autres cas : la source est bcp plus claire comme ça

Oui plus simple, plus clair et plus rapide:

 
   void tab_xor(int n, int *dest, const int *a, const int *b)
    {
      int i;
      for(i = 0 ; i < n ; i++) 
        *c++ = (*a++) ^ (*b++);
    }

Petit rigolo. Je parlais d'une structure quelconque, qui pourrait aussi bien être un vecteur qu'autre chose (par exemple une structure). Accessoirement, dans ton exemple, la fonction appellante doit faire toute l'allocation.

Et en plus, tu renvoies la valeur dans un paramètre, donc :

C'est une maniere sale de repondre au probleme de renvoyer plusieurs parametres.

ça me fait bien marrer (surtout qu'en plus ici il n'y a qu'un paramètre à renvoyer).

La norme C fait que chaque passage par ptr non const est une valeur de sortie
Et je sais parfaitement que la fonction appellante doit faire l'allocation. C'est normal, et c'est mieux. Il faut separer l'allocation, la creation et le calcul

La norme C fait que chaque passage par ptr non const est une valeur de sortie

En C++ aussi (et même de manière encore plus extrêmiste).

Et je sais parfaitement que la fonction appellante doit faire l'allocation. C'est normal, et c'est mieux. Il faut separer l'allocation, la creation et le calcul

On voit celui qui n'a jamais programmé de compilo Je voudrais bien t'y voir, à séparer allocation et calcul dedans (d'ailleurs, qu'entends-tu par création? initialisation?)

>On voit celui qui n'a jamais programmé de compilo Je voudrais bien t'y voir, à séparer allocation et calcul dedans (d'ailleurs, qu'entends-tu par création? initialisation?)
J'ai cree Cf et PedroM en asm.
Meme un assembleur multi-processeurs.
Bien sur il y a des cas ou ce n'est pas possible. C'est vrai.

Kevin Kofler
:

nEUrOO :
Oui, c'est bien du C++ enfin, faut voir avec l'iso c99 on sait jamais

Non, il n'y a pas les références dans le C99. Peut-être dans le C 2009.

ouep, j'ai vérifié apres

Je trouve que le passage par référence est source d'erreur, et je ne l'utiliseque très rarement, quand j'ai à créer une classe C++ et à surdéfinir les opérateurs comme +, =, etc. qui eux, utilisent le passage par référence. Mais je n'ai eu de telle surdéfinition à faire qu'en cours de système en seconde année de BTS, alors autant dire que je n'en fait jamais... Je n'utilise que des pointeurs const/non-const

Un const T&, c'est exactement la même chose qu'un const T* (pas plus de risque d'erreur)

peut-être, mais au moins, sans passage par référence, tu peux être sur que la fonction appelée ne modifiera pas ta variable, même si tu n'as pas le prototype sous les yeux...

Et avec un pointeur ta fonction ne modifiera pas la variable?

(je parle de passage par référence pour les structures, hein, pas pour les entiers : parce que s'il s'agit de renvoyer plusieurs valeurs, autant renvoyer un pair<x,y>)

On peut aussi la passer par valeur, la structure. Dans notre patch pour GCC, je passe tous les struct smap_bcd_float par valeur.

Oui, mais si elle est un peu grosse c'est pas du tout efficace. En général, en C, pour passer des structures on passe plutôt des pointeurs, si l'objet est déjà stocké qq part en RAM.