passage par réference?

On Sat, 20 Nov 2004 18:22:59 +0100, "jmarc"
<jean.marc.cholet@wanadoo.fr>:

void main()

int main()

{
int * tab=new int[10];

std::vector<int> tab (10);

ou carrément, puisque tu connais la taille du tableau à la
compilation :

int tab [10];

inittab(tab);

A quoi ça sert ?



--
;-)

On Sat, 20 Nov 2004 18:22:59 +0100, "jmarc"
<jean.marc.cholet@wanadoo.fr>:

{
int * tab=new int[10];
[...]

Note qu'ici, il ne faut pas oublier de nettoyer la mémoire :
delete[] tab;

}

Bon, je sens bien qu'il s'agit là d'un exercice donné soit par un
prof, soit par un livre ; néanmoins, il me semble que donner un
exemple de programme fait suivant les règles sera plus instructif que
te laisser t'embourber dans une solution bien mal partie.

Note que si tu suis des cours de "C++", et que ton prof t'enseigne les
techniques que j'ai pu voir dans ton message, on ne pourra pas faire
grand-chose pour toi -- il s'agit en effet d'un cours de mauvais C,
vaguement transposé en C++.


Je vais commencer par une version assez proche de ce que tu as fait :



typedef std::vector<int> Tableau;

void AfficheTableau (Tableau const& t)
// N'hésite pas à utiliser des identifiants très explicites
{
for (int j=0; j<t.size(); ++j) cout<<t[j]<<"n";
// Note qu'en C++, les indices des tableaux commencent à 0
}

void Calculsuite (Tableau& dest)
{
// int a,b,sauv;
// Ceci est du C ; en C++, on déclare les variables au fur et à mesure
int a= 1;
int b= 2;
for (int j=0; j<dest.size(); ++j)
{
cout<<a<<"n";
dest[j]=a;
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table (nb_elements);
Calculsuite (table);
AfficheTableau (table);
}

int main()
{
Fibonacci (10);
}




Au lieu de créer d'avance un tableau avec un nombre d'éléments défini,
on peut modifier légèrement le code :

void CalculSuite (Tableau& dest, int nb_elements)
{
int a= 1;
int b= 2;
for (int j=0; j<nb_elements; ++j)
{
cout<<a<<"n";
dest.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table;
CalculSuite (table, nb_elements);
AfficheTableau (table);
}



Ce qui permet des fantaisies, par exemple, au lieu de calculer dix
éléments, on calcule jusqu'à ce qu'un certain nombre soit atteint :

void CalculSuite_Max (Tableau& dest, int maximum)
{
int a= 1;
int b= 2;
while (a<maximum)
{
cout<<a<<"n";
dest.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci_Max (int maximum)
{
Tableau table;
CalculSuite (table, maximum);
AfficheTableau (table);
}



Note qu'on peut également demander à "CalculSuite()" de renvoyer
carrément le tableau. Ce n'est pas forcément aussi rapide, car il y a
(peut-être) une ou deux copies du tableau, mais pour des petits
tableaux, ça n'a pas grande importance :

Tableau CalculSuite (int nb_elements)
{
Tableau reponse;

int a= 1;
int b= 2;
for (int j=0; j<nb_elements; ++j)
{
cout<<a<<"n";
reponse.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
return reponse;
}

void Fibonacci (int nb_elements)
{
Tableau table= CalculSuite (nb_elements);
AfficheTableau (table);
}



La fonction d'affichage peut aussi être modifiée pour être plus proche
de ce qu'on fait d'habitude en C++ :

void AfficheTableau (Tableau const& t)
{
for (Tableau::const_iterator i= t.begin();
i != t.end(); ++i)
std::cout << *i << 'n';
}

voire

void AfficheTableau (Tableau const& t)
{
std::copy (t.begin(), t.end(),
std::ostream_iterator<int> (std::cout, "n"));
}



--
;-)

je te remercie

"Fabien LE LEZ" <gramster@gramster.com> a écrit dans le message de news:
orvup0t6300r5ak7vb0iej39sctr5qjnkq@4ax.com...

On Sat, 20 Nov 2004 18:22:59 +0100, "jmarc"
<jean.marc.cholet@wanadoo.fr>:

{
int * tab=new int[10];
[...]

Note qu'ici, il ne faut pas oublier de nettoyer la mémoire :
delete[] tab;

}

Bon, je sens bien qu'il s'agit là d'un exercice donné soit par un
prof, soit par un livre ; néanmoins, il me semble que donner un
exemple de programme fait suivant les règles sera plus instructif que
te laisser t'embourber dans une solution bien mal partie.

Note que si tu suis des cours de "C++", et que ton prof t'enseigne les
techniques que j'ai pu voir dans ton message, on ne pourra pas faire
grand-chose pour toi -- il s'agit en effet d'un cours de mauvais C,
vaguement transposé en C++.


Je vais commencer par une version assez proche de ce que tu as fait :



typedef std::vector<int> Tableau;

void AfficheTableau (Tableau const& t)
// N'hésite pas à utiliser des identifiants très explicites
{
for (int j=0; j<t.size(); ++j) cout<<t[j]<<"n";
// Note qu'en C++, les indices des tableaux commencent à 0
}

void Calculsuite (Tableau& dest)
{
// int a,b,sauv;
// Ceci est du C ; en C++, on déclare les variables au fur et à mesure
int a= 1;
int b= 2;
for (int j=0; j<dest.size(); ++j)
{
cout<<a<<"n";
dest[j]=a;
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table (nb_elements);
Calculsuite (table);
AfficheTableau (table);
}

int main()
{
Fibonacci (10);
}




Au lieu de créer d'avance un tableau avec un nombre d'éléments défini,
on peut modifier légèrement le code :

void CalculSuite (Tableau& dest, int nb_elements)
{
int a= 1;
int b= 2;
for (int j=0; j<nb_elements; ++j)
{
cout<<a<<"n";
dest.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table;
CalculSuite (table, nb_elements);
AfficheTableau (table);
}



Ce qui permet des fantaisies, par exemple, au lieu de calculer dix
éléments, on calcule jusqu'à ce qu'un certain nombre soit atteint :

void CalculSuite_Max (Tableau& dest, int maximum)
{
int a= 1;
int b= 2;
while (a<maximum)
{
cout<<a<<"n";
dest.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci_Max (int maximum)
{
Tableau table;
CalculSuite (table, maximum);
AfficheTableau (table);
}



Note qu'on peut également demander à "CalculSuite()" de renvoyer
carrément le tableau. Ce n'est pas forcément aussi rapide, car il y a
(peut-être) une ou deux copies du tableau, mais pour des petits
tableaux, ça n'a pas grande importance :

Tableau CalculSuite (int nb_elements)
{
Tableau reponse;

int a= 1;
int b= 2;
for (int j=0; j<nb_elements; ++j)
{
cout<<a<<"n";
reponse.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
return reponse;
}

void Fibonacci (int nb_elements)
{
Tableau table= CalculSuite (nb_elements);
AfficheTableau (table);
}



La fonction d'affichage peut aussi être modifiée pour être plus proche
de ce qu'on fait d'habitude en C++ :

void AfficheTableau (Tableau const& t)
{
for (Tableau::const_iterator i= t.begin();
i != t.end(); ++i)
std::cout << *i << 'n';
}

voire

void AfficheTableau (Tableau const& t)
{
std::copy (t.begin(), t.end(),
std::ostream_iterator<int> (std::cout, "n"));
}



--
;-)

http://www.giromini.org/usenet-fr/repondre.html

note que je ne suis pas de cours,
j'ai décidé de m'emmerder à 40 ans à faire un peu de programmation histoire
de voir ce que s'est!
voila mais merci j'ai apprécier tes réponses que j'essaie de comprendre

"Fabien LE LEZ" <gramster@gramster.com> a écrit dans le message de news:
orvup0t6300r5ak7vb0iej39sctr5qjnkq@4ax.com...

On Sat, 20 Nov 2004 18:22:59 +0100, "jmarc"
<jean.marc.cholet@wanadoo.fr>:

{
int * tab=new int[10];
[...]

Note qu'ici, il ne faut pas oublier de nettoyer la mémoire :
delete[] tab;

}

Bon, je sens bien qu'il s'agit là d'un exercice donné soit par un
prof, soit par un livre ; néanmoins, il me semble que donner un
exemple de programme fait suivant les règles sera plus instructif que
te laisser t'embourber dans une solution bien mal partie.

Note que si tu suis des cours de "C++", et que ton prof t'enseigne les
techniques que j'ai pu voir dans ton message, on ne pourra pas faire
grand-chose pour toi -- il s'agit en effet d'un cours de mauvais C,
vaguement transposé en C++.


Je vais commencer par une version assez proche de ce que tu as fait :



typedef std::vector<int> Tableau;

void AfficheTableau (Tableau const& t)
// N'hésite pas à utiliser des identifiants très explicites
{
for (int j=0; j<t.size(); ++j) cout<<t[j]<<"n";
// Note qu'en C++, les indices des tableaux commencent à 0
}

void Calculsuite (Tableau& dest)
{
// int a,b,sauv;
// Ceci est du C ; en C++, on déclare les variables au fur et à mesure
int a= 1;
int b= 2;
for (int j=0; j<dest.size(); ++j)
{
cout<<a<<"n";
dest[j]=a;
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table (nb_elements);
Calculsuite (table);
AfficheTableau (table);
}

int main()
{
Fibonacci (10);
}




Au lieu de créer d'avance un tableau avec un nombre d'éléments défini,
on peut modifier légèrement le code :

void CalculSuite (Tableau& dest, int nb_elements)
{
int a= 1;
int b= 2;
for (int j=0; j<nb_elements; ++j)
{
cout<<a<<"n";
dest.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table;
CalculSuite (table, nb_elements);
AfficheTableau (table);
}



Ce qui permet des fantaisies, par exemple, au lieu de calculer dix
éléments, on calcule jusqu'à ce qu'un certain nombre soit atteint :

void CalculSuite_Max (Tableau& dest, int maximum)
{
int a= 1;
int b= 2;
while (a<maximum)
{
cout<<a<<"n";
dest.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci_Max (int maximum)
{
Tableau table;
CalculSuite (table, maximum);
AfficheTableau (table);
}



Note qu'on peut également demander à "CalculSuite()" de renvoyer
carrément le tableau. Ce n'est pas forcément aussi rapide, car il y a
(peut-être) une ou deux copies du tableau, mais pour des petits
tableaux, ça n'a pas grande importance :

Tableau CalculSuite (int nb_elements)
{
Tableau reponse;

int a= 1;
int b= 2;
for (int j=0; j<nb_elements; ++j)
{
cout<<a<<"n";
reponse.push_back (a);
int sauv=b;
b=a+b;
a=sauv;
}
return reponse;
}

void Fibonacci (int nb_elements)
{
Tableau table= CalculSuite (nb_elements);
AfficheTableau (table);
}



La fonction d'affichage peut aussi être modifiée pour être plus proche
de ce qu'on fait d'habitude en C++ :

void AfficheTableau (Tableau const& t)
{
for (Tableau::const_iterator i= t.begin();
i != t.end(); ++i)
std::cout << *i << 'n';
}

voire

void AfficheTableau (Tableau const& t)
{
std::copy (t.begin(), t.end(),
std::ostream_iterator<int> (std::cout, "n"));
}



--
;-)

"jmarc" <jean.marc.cholet@wanadoo.fr> writes:

int * tab=new int[10];
inittab(tab); /*erreur à la compilation ne peut convertir int [10] en int
&*/

[...]

void inittab(int * t)

Je suppose que tu as copié la mauvaise version : Il n'y a pas de
référence dans ton code !

Mais effectivement, on ne peut pas convertir un int[10] en int& :

int[10] est un tableau de 10 entiers, qui en pratique est la même
chose qu'un pointeur sur une zone mémoire allouée de taille
10*sizeof(int).

int& est un entier, qui se trouve être "le même" qu'une autre variable
du programme, donc, modifier l'un modifiera l'autre. En pratique, le
compilateur mettra probablement un pointeur à la place, mais ce n'est
pas ton problème.

Dans le cas des tableaux "à la C", si tu ne modifies que les éléments
du tableau, pas besoin de passage par référence, de toutes façons.

--
Matthieu

"jmarc" <jean.marc.cholet@wanadoo.fr> writes:

quand j'écris ces lignes qu'est ce qui gene le compilateur,
j'ai indiqué la ligne en erreur,
moi je trouve ca plus facile qu'avec des pointeurs!!
(ce programme calcul la suite de fibonacci jusqu'à 10)
merci

À part void main à la place de int main, je ne vois pas de
problèmes pouvant indisposer un compilateur avec ce
programme (ah si, j'en ai un qui indique qu'exporter des
fonctions d'une unité de compilation contenant main peut
être de mauvais style).

Ce qui ne veut pas dire que je n'ai pas de remarques. Voir
aussi le message de Fabien, je me contenterai de remarques
sur la voie que tu as choisie et sur l'erreur que je devine.

#include <iostream>
using namespace std;

void calculsuite(int *);
void inittab(int *);
void afftab(int *);

Certains utilisent de préférence
void calculsuite(int[]);
pour indiquer que c'est un pointeur vers un tableau. Les
deux notations sont strictement identiques du point de vue
de la sémantique.

void main()

int main()

puisque j'en ai parlé.

{
int * tab=new int[10];
10 constante magique?

inittab(tab); /*erreur à la compilation ne peut convertir int [10] en int
&*/
calculsuite(tab);
afftab(tab);

Il vaut mieux penser à libérer la mémoire, bien que dans
main on peut discutter de l'intérêt. L'avantage dans ce cas
à ne pas libérer la mémoire -- normalement l'OS s'en occupera
de toute façon -- c'est que ça prend moins de temps. Des
appli qui mettent plusieurs minutes à quitter, c'est
pénible. L'avantage, c'est que des outils du genre purify
ne vont pas dire qu'il s'agit d'une fuite de mémoire.

}

void calculsuite(int *t)
{
int a,b,sauv;
a=1;
b=2;

La suite de Fibonacci commence par 1 1 et pas 1 2 :-)

for (int j=1;j<10;j++)

Les indices des tableaux en C commencent à 0.
10 constante magique?

{
cout<<a<<"n";
t[j]=a;
sauv=b;
b=a+b;
a=sauv;
}
}

Ce n'est pas comme ça que je ferais:

t[0] = 1;
t[1] = 1;
for (int i = 2; i < tableSize; ++i) {
t[i] = t[i-1] + t[i-2];
}

et je ne passerais à une autre écriture que si on me montre
que ça pose un problème de performance.

void inittab(int * t)
{
for (int j=1;j<10;j++) t[j]=0;
}

À quoi ça sert, de toute manière on écrase ces valeurs?

Void afftab(int * t)
void

{
for (int j=1;j<10;j++) cout<<t[j]<<"n";
}
Deuxième affichage de la même chose.

On vu du message d'erreur, je suppose que tu as essayé de
remplacer
void inittab(int *);
par
void inittab(int&);

Petits essais de compilateurs, j'en ai un qui donne

error: a reference of type "int &" (not const-qualified)
cannot be initialized with a value of type "int [10]"

si en plus j'ai

int tab[10];

Ce qui se passe est que si le langage entretient une
certaine confusion entre les tableaux "C" et les pointeurs,
il n'y a rien de tel entre tableau et référence. Donc, tu
devrais faire

void inittab(int(&)[10]);

Pour indiquer que tu veux passer une référence sur un
tableau de 10 entiers. (Attention int&[10] indiquerait un
tableau de 10 références vers des entiers, mais c'est pas
autorisé).

À nouveau, avoir une constante magique comme 10 qui apparait
à différent endroit, c'est pas bien. Ça pose des problèmes
car un jour ou l'autre on va vouloir la remplacer par autre
chose et il va falloir trouver tous les endroits où 10
apparait pour faire le remplacement. Et les examiner pour
vérifier si ce n'est pas une coincidance que ce soit aussi
10. On peut mettre une constante, mais si on utilise les
référence le programme ne pourra fonctionner que pour une
valeur donnée et pas la demander. On peut utiliser des
pointeurs et de l'allocation dynamique en passant la
taille. C'est ce qu'on ferait en C. En C++, il y a un type
std::vector fait justement pour ça. Voir le message de Fabien.

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

On Sat, 20 Nov 2004 20:04:39 +0100, "jmarc"
<jean.marc.cholet@wanadoo.fr>:

note que je ne suis pas de cours,

http://www.giromini.org/usenet-fr/repondre.html

vraiment je suis désolé pour moi mais pkoi
je peux pas compiler cette solution de fabien
j'ai le message d'erreur vector is not a member of std,
ia des erreurs?

#include <iostream>
using namespace std;

typedef std::vector<int> Tableau;

void AfficheTableau (Tableau const& t)

{
for (int j=0; j<t.size(); ++j) cout<<t[j]<<"n";

}

void Calculsuite (Tableau & dest)
{

int a= 1;
int b= 2;
for (int j=0; j<dest.size(); ++j)
{
cout<<a<<"n";
dest[j]=a;
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table (nb_elements);
Calculsuite (table);
AfficheTableau (table);
}

int main()
{
Fibonacci (10);
}

"jmarc" <jean.marc.cholet@wanadoo.fr> a écrit dans le message de news:
419f7d70$0$8186$8fcfb975@news.wanadoo.fr...

quand j'écris ces lignes qu'est ce qui gene le compilateur,
j'ai indiqué la ligne en erreur,
moi je trouve ca plus facile qu'avec des pointeurs!!
(ce programme calcul la suite de fibonacci jusqu'à 10)
merci

#include <iostream>
using namespace std;

void calculsuite(int *);
void inittab(int *);
void afftab(int *);

void main()

{
int * tab=new int[10];
inittab(tab); /*erreur à la compilation ne peut convertir int [10] en int
&*/
calculsuite(tab);
afftab(tab);
}

void calculsuite(int *t)
{
int a,b,sauv;
a=1;
b=2;
for (int j=1;j<10;j++)
{
cout<<a<<"n";
t[j]=a;
sauv=b;
b=a+b;
a=sauv;
}
}


void inittab(int * t)
{
for (int j=1;j<10;j++) t[j]=0;
}

void afftab(int * t)
{
for (int j=1;j<10;j++) cout<<t[j]<<"n";
}

"jmarc" <jean.marc.cholet@wanadoo.fr> a écrit dans le message de news:
419fbceb$0$8180$8fcfb975@news.wanadoo.fr...

vraiment je suis désolé pour moi mais pkoi
je peux pas compiler cette solution de fabien
j'ai le message d'erreur vector is not a member of std,
ia des erreurs?

pas la peine j'ai trouvé
merci

#include <iostream>
using namespace std;

typedef std::vector<int> Tableau;

void AfficheTableau (Tableau const& t)

{
for (int j=0; j<t.size(); ++j) cout<<t[j]<<"n";

}

void Calculsuite (Tableau & dest)
{

int a= 1;
int b= 2;
for (int j=0; j<dest.size(); ++j)
{
cout<<a<<"n";
dest[j]=a;
int sauv=b;
b=a+b;
a=sauv;
}
}

void Fibonacci (int nb_elements)
{
Tableau table (nb_elements);
Calculsuite (table);
AfficheTableau (table);
}

int main()
{
Fibonacci (10);
}

"jmarc" <jean.marc.cholet@wanadoo.fr> a écrit dans le message de news:
419f7d70$0$8186$8fcfb975@news.wanadoo.fr...

quand j'écris ces lignes qu'est ce qui gene le compilateur,
j'ai indiqué la ligne en erreur,
moi je trouve ca plus facile qu'avec des pointeurs!!
(ce programme calcul la suite de fibonacci jusqu'à 10)
merci

#include <iostream>
using namespace std;

void calculsuite(int *);
void inittab(int *);
void afftab(int *);

void main()

{
int * tab=new int[10];
inittab(tab); /*erreur à la compilation ne peut convertir int [10] en int
&*/
calculsuite(tab);
afftab(tab);
}

void calculsuite(int *t)
{
int a,b,sauv;
a=1;
b=2;
for (int j=1;j<10;j++)
{
cout<<a<<"n";
t[j]=a;
sauv=b;
b=a+b;
a=sauv;
}
}


void inittab(int * t)
{
for (int j=1;j<10;j++) t[j]=0;
}

void afftab(int * t)
{
for (int j=1;j<10;j++) cout<<t[j]<<"n";
}