Argument et classe Générique

bonjour et merci de prendre quelques secondes pour m'aider :D

voilà ma première question :
quels sont les avantages et les inconvénients du passage par valeur, par adresse et par références?
ps : est-ce qu'il serait possible de mettre un exemple de chaque pour que je vois facilement.

Merci .

2 question :

Je dois créer une classe générique qui contient un tableau statique de 5 éléments de type quelcnque
Comment dois je m'y prendre ?

Merci

Salut,
As-tu regardé dans la faq ?
http://cpp.developpez.com/faq/cpp/?p...sage_parametre
http://cpp.developpez.com/faq/cpp/?p...creation_class
a+
jmv

donc ça donnera :
pour la classe générique :

Code:

---

1 2 3

template <class T> class Ensemble { T *tab=new T[5]; };

---

?? oui ou non ? merci

non

Code:

---

1 2 3 4 5 6 7 8 9

template <typename T> class Ensemble { public: // mettre ici les méthodes publiques   private: T tab[5]; };

---

Bien que "template <class T>" soit correct il vaut mieux utiliser le mot clé typename.

Citation:

---

Envoyé par jmv

Bien que "template <class T>" soit correct il vaut mieux utiliser le mot clé typename.

---

C'est faux. Ca ne change strictement rien.
Toutefois, mettre typename indique à ceux qui liront le code que le paramètre peut a priori être un type fondamental aussi bien qu'un type créé par l'utilisateur ; alors que mettre class indique que le paramètre template sera a priori un type créé par l'utilisateur. Mais ça ne change strictement rien, le compilateur s'en fout.

Citation:

---

Envoyé par Klaine

Je dois créer une classe générique qui contient un tableau statique de 5 éléments de type quelcnque
Comment dois je m'y prendre ?

Merci

---

Ce que tu veux faire existe déjà : Boost.Array. Si c'est un exercice, ok refais-le.

boost::array fais ce que tu veux, sauf que l'on paramètre aussi la classe avec le nombre d'éléments que contiendra le tableau statique. De plus, son interface est compatible avec les algorithmes de la bibliothèque standard (tu peux appeler std::sort, std::foreach etc. dessus).

encore une question ,ça veut dire quoi surcharger l'opérateur << ?

surcharger ++, --, ==, ok ça je comprend mais <<,je ne vois pas ce que c'est

Ex si je fais ça , est-ce que c'est bon :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Class Ensemble{   int x; public : Ensemble operator << (Ensemble); };   // car la surcharge doit afficher la valeur de l'ensemble Ensemble Ensemble :: operator << (Ensemble Z) { std :: cout << Z.x; // return this return *this; }

---

Merci

La réponse est dans la :faq:

Salut,

Juste une chose, c'est à mon avis une bonne habitude à prendre que de ne pas implémenter les méthodes de surchage d'opérateur en temps que méthodes de classe, mais en temps que fonctions amies. Sinon, tu peux tomber sur des problèmes du type:

Code:

---

1 2 3 4 5 6 7 8

class MyInt{ private : int _i; public: MyInt(int i=0); MyInt operator+(MyInt& j); };

---

Code:

---

1 2 3 4 5 6

MyInt::operator+(int j){ MyInt tmp; tmp._i= this->_i + j; return tmp; };

---

utilisation:

Code:

---

1 2 3 4

MyInt myInt(20); myInt = myInt+10; //ok myInt = 10+myInt; //ko l operateur + n'est pas surdéfini pour le type de base "int"

---

Alors qu'en ayant déclarer la(les) méthodes de surchage comme çà :

Code:

---

1 2 3

friend MyInt operator+(MyInt& i, int j); friend MyInt operator+(int j, MyInt& i);

---

Le problème ne se pose pas ...

Soit en ami soit en définissant tous les accesseurs nécessaires ;)

j'y ai pensé mais il faut bien sur que je sois capable de le faire sans les fonctions amies , vu qu'une fonction amie possède les mêmes privilèges d'accès qu'une méthode
avec les fonctions mies , ils faut tout définir 8O

voilà par contre comment je fais pour faire qu'il m'affiche Z.x vu qu'il me dit qu'il est privé

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#include<iostream>   class Ensemble{ int x; public : Ensemble (int); friend std::ostream& operator <<(std::ostream& Stream, const Ensemble); };   Ensemble :: Ensemble(int valeur) { x=valeur; }     std::ostream& operator <<(std::ostream& Stream, const Ensemble & Z) { return Stream << Z.x; }   int main() { Ensemble E1(5); printf("avec surcharge operator <<:\n"); }

---

Citation:

---

Soit en ami soit en définissant tous les accesseurs nécessaires

---

Vrai, mais le problème est que tu ne peux pas tout le temps définir ces accesseurs, principalement dans deux cas:
Un des acteurs de la surcharge est un type de base (difficile de surdéfinir l'opérateur + pour un float)
On a pas accès au code source -ou on ne veut pas le modifier- d'un des acteurs de la surchage ...

++