Discussion :

[AntoineCompagnie]

Bonsoir !

J'essaye de coder la fonction factorielle en C++ en envoyant le nombre ou le tableau représentant les chiffres composant les multiplicateurs de la factorielle.
Cependant dès que je passe par la fonction référencant, je n'arrive pas à faire compiler lorsque je passe le tableau :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
error: cannot convert ‘int (*)[nombre]’ to ‘int*’ for argument ‘1’ to ‘int facto_reference(int*, size_t)’
  resultat_facto = facto_reference(&tableauNombre,nombre);

Je pense que l'erreur vient de la taille du tableau que j'envoie...


Pouvez-vous m'aider ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
#include <iostream>
#include <cstdlib>
#include <stdio.h>
 
using namespace std;
 
int facto(int x){
 
	int y=1;
 
	for (int i = 1; i< x+1; i++){
 
		y = y*i;
	}
 
	return y;
 
}
 
int facto_reference(int *tableauEntiers, size_t taille){
 
	int factorielle = 0;
 
	for(int i = 0; i < taille+1; ++i )
	factorielle *= *( tableauEntiers + i );
 
	cout << "la moyenne du tableau avec le formalisme pointeur est " << factorielle <<endl;
 
}
 
 
int main(){
	int nombre;
	int resultat, resultat_facto;
 
	cout << " entrez le nombre à factorialiser : " << endl;
	cin >> nombre;
	int tableauNombre[nombre];
	resultat = facto(nombre);
	cout << "le nombre factorialisé est : " << resultat << endl;
	for(int i = 0; i<nombre+1;i++){
		tableauNombre[i];
	}
	resultat_facto = facto_reference(&tableauNombre,nombre);
	cout << "le nombre factorialisé référencé est : " << resultat << endl;
 
}

[ternel]

il te dit qu'il ne sais pas convertir un int (*)[] en int *.
C'est à dire un pointeur de tableau d'entier en pointeur d'entier.

L'erreur? avoir donné &tableau comme valeur à ton int* tableaureference.
Il faut donner le pointeur sur le premier élément du tableau, ce qui est &tableau[0] ou, par raccourci de syntaxe: tableau

[dalfab]

Bonjour,

Et je m'étonne que le compilateur n'ait pas indiqué un beau warning ligne 43!
Je devine le résultat de facto_reference() qui consiste à multiplier 0 par plein d'autre nombres.

[Bousk]

De toutes façons ce code est faux.
int tableauNombre[nombre]; où nombre est une variable dont la valeur n'est connue qu'à l'exécution n'a jamais été une syntaxe valide en C++. C'est un VLA, qui existe uniquement dans une certaine version du C.
Faire du C++ c'est pas remplacer prinf par cout. Utiliser un std::vector c'est le B.A.BA.

[AntoineCompagnie]

D'acc, j'ai pris en compte vos conseil pour le passage par référence, il fallait simplement envoyer le tableau comme argument.
Comment faire désormais pour calculer la factorielle une fois qu'on a les chiffres qui compose le calcul dans ce tableau ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
int facto_reference(int *tableauEntiers, size_t taille){
 
	int factorielle = 1;
 
	for(int i = 1; i < taille+1; ++i )
	factorielle *= *( tableauEntiers + i );
 
	return factorielle;
 
}
 
 
int main(){
	int nombre;
	int resultat, resultat_facto;
 
	cout << " entrez le nombre à factorialiser : " << endl;
	cin >> nombre;
	int tableauNombre[nombre];
 
	cout << "le nombre factorialisé est : " << resultat << endl;
	for(int i = 0; i<nombre+1;i++){
		tableauNombre[i];
	}
	resultat_facto = facto_reference(tableauNombre,nombre);
	cout << "le nombre factorialisé est : " << resultat_facto << endl;
 
}

[Matt_Houston]

Ça c'est un problème d'algorithmique, plus de langage. Comment ferais-tu avec un crayon et une feuille de papier ?

À titre d'indice tu utilises ici ton tableau comme un paramètre d'entrée, alors que c'est un paramètre de sortie si j'en crois ton objectif : y stocker le résultat.

[Invité]

Bonsoir,

Active au minimum les options -Wall -Wextra -pedantic, ton compilateur pourra déjà te dire des choses :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
g++ -Wall -Wextra -pedantic main.cpp
main.cpp: In function 'int facto_reference(int*, size_t)':
main.cpp:5:19: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
  for(int i = 1; i < taille+1; ++i )
                 ~~^~~~~~~~~~
main.cpp: In function 'int main()':
main.cpp:19:26: warning: ISO C++ forbids variable length array 'tableauNombre' [-Wvla]
  int tableauNombre[nombre];
                          ^
main.cpp:23:18: warning: statement has no effect [-Wunused-value]
   tableauNombre[i];
   ~~~~~~~~~~~~~~~^
main.cpp:21:46: warning: 'resultat' may be used uninitialized in this function [-Wmaybe-uninitialized]
  cout << "le nombre factorialisé est : " << resultat << endl;
                                              ^~~~~~~~

Les VLA (Variable Length Array) viennent du langage C (norme C99). Il n'existent pas en C++. Utilise std::vector à la place.

[AntoineCompagnie]

Ça c'est un problème d'algorithmique, plus de langage. Comment ferais-tu avec un crayon et une feuille de papier ?

À titre d'indice tu utilises ici ton tableau comme un paramètre d'entrée, alors que c'est un paramètre de sortie si j'en crois ton objectif : y stocker le résultat.

Non, il s'agit d'utiliser les nombres stocké par adresse dans le tableau d'entiers (et qui représente les chiffres nécessaires à l'opération de la factorielle) et les multiplier pour calculer la factorielle.

Il suffisait donc de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
int facto_reference(int *tableauEntiers, size_t taille){
 
	int factorielle = 1;
 
	for(int i = 1; i < taille; ++i ){
		cout << *( tableauEntiers + i ) <<endl;
		factorielle *= *( tableauEntiers + i );
	}
 
	return factorielle;
 
}
 
 
int main(){
	int nombre;
	int resultat, resultat_facto;
 
	cout << " entrez le nombre à factorialiser : " << endl;
	cin >> nombre;
	int tableauNombre[nombre];
 
	cout << "le nombre factorialisé est : " << facto(nombre) << endl;
	resultat = facto(nombre);
	cout << "le nombre factorialisé est : " << resultat << endl;
	for(int i = 0; i<nombre;i++){
		tableauNombre[i] = i+1;
		cout << tableauNombre[i]<<endl;
	}
	resultat_facto = facto_reference(tableauNombre,nombre);
	cout << "le nombre factorialisé est : " << resultat_facto << endl;
 
}

Merci pour votre aide ! Néanmoins, je ne suis pas encore sûr de bien maitriser les adresses.

[Bousk]

Ton initialisation de tableauNombre est toujours fausse.
On dit factorisé.
*(tab + i) == tab[i]

[Matt_Houston]

Ça n'est pas la factorielle mais le produit des éléments du vecteur : . Il ne correspond à la factorielle de son nombre d'éléments que lorsque ses éléments valent respectivement leur propre rang plus un.

Pour calculer la factorielle d'un entier naturel n tu n'as besoin que de n, pas de n entiers. Alors si tu ne l'utilises pas non plus comme paramètre de sortie, à quoi peut bien servir ton tableau ?

[AntoineCompagnie]

Ton initialisation de tableauNombre est toujours fausse.
On dit factorisé.
*(tab + i) == tab[i]

Pourtant j'ai essayé 3 ca me renvoie 6 et 4 ça me renvoie 24...

Je suis prêt à apprendre et à utiliser ce fameux vecteur pour faire quelque chose de parfait c++ mais je ne l'ai pas encore vu en cours ... Pouvez vous me guider ?

Ça n'est pas la factorielle mais le produit des éléments du vecteur : . Il ne correspond à la factorielle de son nombre d'éléments que lorsque ses éléments valent respectivement leur propre rang plus un.

Pour calculer la factorielle d'un entier naturel n tu n'as besoin que de n, pas de n entiers. Alors si tu ne l'utilises pas non plus comme paramètre de sortie, à quoi peut bien servir ton tableau ?

C'était mon idée pour refaire une factorielle : prendre un nombre n, remplir un tableau de taille n avec les éléments allant de 0 à n et multiplier ensuite ces éléments dont on a attrapé l'adresse du tableau les contenant. Je trouvais que ça faisait le boulot ... Mais je suis prêt à apprendre à mieux faire !

[Matt_Houston]

Ben je n'en vois pas l'intérêt sachant que pour obtenir l'entier de rang inférieur il suffit de retrancher 1. La plage de données est connue, tu n'as pas besoin de la calculer à l'avance (surtout que dans le cas présent tu y perds en terme de performance).

L'intérêt que pourrait avoir ton tableau au sein de la fonction c'est en l'utilisant comme paramètre de sortie pour y stocker par exemple le résultat de tous les produits intermédiaires, soit les factorielles de tous les nombres de 1 à n.

Que voulais-tu accomplir à l'origine ?

[AntoineCompagnie]

Que voulais-tu accomplir à l'origine ?

A l'origine j'essaye de réaliser le programme décrit dans l'énoncé suivant :

Donnez le code de la fonction facto transformant un nombre n en
son factoriel n! = n × (n − 1) × . . . × 2 , par exemple on déclare int x=4; puis après l'appel
on a x = 24 , dans les cas suivants:
1) L'appel avait été effectué par l'instruction facto(&x);
2) L'appel avait été effectué par l'instruction facto(x);
3) L'appel avait été effectué par l'instruction x=facto(x);

Je pensais que ce tableau me permettait de réaliser facto(&x), c'est à dire créer une fonction renvoyant la factorielle d'un nombre par passage par référence.

[Bousk]

Dans facto(&x); x sera passé par pointeur.

[ternel]

Peut-être fais-tu la confusion classique entre les deux usages du mot référence.
en anglais, nous avons handler et reference.

La définition large de "passage par référence" signifie de transmettre à une fonction un moyen d'accéder à l'objet sans le copier.
Cela s'oppose au "passage par valeur", qui consiste à ne transmettre que la valeur de l'objet, la fonction manipulant une copie indépendante.

Le C++ est défini de manière simple: tout argument est transmis par valeur.
C'est à dire que la première chose faite par l'appel d'une fonction, c'est d'initialiser des variables locales, qui sont les paramêtres de la fonction, avec les valeurs données en argument.

Par abus de langage, en C, on parle de passage par référence quand on utilise un pointeur en argument, car la fonction peut alors modifier le pointé, qui se trouve être une valeur appartenant à l'appelant.

La confusion arrive maintenant:
En C++, il existe les types références, comme int& qui sont justement des nouveaux noms à des choses existantes.
L'usage strictement C++ de "passage par référence" ne concerne que ces références.

Selon les personnes qui parlent, l'expression passage par référence peut désigner soit collectivement les pointeurs et les références, soit uniquement ces dernières.

Dans ton énoncé, la seconde version est une référence, car elle doit modifier x.
La première version est un pointeur, et correspond à la définition large de "passage par référence".

[Matt_Houston]

J'ajouterais les notions suivantes (qui ne sont pas spécifiques au langage C++) aux explications de ternel :

• on parle de paramètre d'entrée lorsque la fonction utilise les informations du paramètre pour effectuer son traitement ;
• on parle de paramètre de sortie lorsque la fonction utilise le paramètre pour y stocker le résultat de son traitement et le transmettre à la fonction appelante ;
• on parle de paramètre d'entrée / sortie lorsque le traitement dépend de la valeur initiale du paramètre et qu'on y stocke par la suite le résultat.

Un paramètre passé par valeur est donc toujours un paramètre d'entrée, puisqu'on ne peut altérer la valeur qu'il avait dans la portée appelante. Un paramètre passé par référence (au sens large comme le dit ternel) peut, lui, être d'entrée, de sortie ou d'entrée / sortie.

Appliqué à ton énoncé :

• facto(&x); suppose un passage par référence (au sens large du terme) : on calcule la factorielle de la valeur stockée à l'adresse de x et on y écrase cette valeur avec le résultat ;
• facto(x); suppose un passage par référence (au sens C++ du terme) : on calcule la factorielle de x dont on remplace la valeur avec le résultat (techniquement, le traitement machine est identique au cas précédent) ;
• x = facto(x); suppose un passage par copie : on calcule la factorielle de x et on retourne le résultat, qu'il revient à l'appelant de stocker quelque part (ici dans x).

Tu n'as aucunement besoin de ré-implémenter l'algorithme pour chacune de ces formes d'appel. Une fois suffit. C'est uniquement la façon dont on transmet l'information aller et retour qui change, pas la manière de calculer la factorielle. Deux de ces trois fonctions peuvent invoquer la dernière, par exemple, qui, elle, effectuera le traitement.

[AntoineCompagnie]

Merci pour toutes ces précisions.

Malheureusement, lorsque je fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
cout << "le nombre factorialisé est : " << facto(&nombre) << endl;
	cout << "le nombre factorialisé est : " << facto(nombre) << endl;

le compilateur apprècie beaucoup moins le passage par référence

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
invalid conversion from ‘int*’ to ‘int’ [-fpermissive]
  cout << "le nombre factorialisé est : " << facto(&nombre) << endl;

Voici la fonction facto du coup ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
int facto(int x){
 
	int y=1;
 
	for (int i = 1; i< x+1; i++){
 
		y = y*i;
	}
 
	return y;
 
}

[ternel]

Si tu n'as qu'une fonction, tu n'as qu'une possibilité.
pour appeler facto(&x), il faut avoir déclaré (et défini) une fonction facto capable d'accepter la valeur de &x.

Le compilateur te dis précisément qu'il ne parvient pas à convertir int* en int

[AntoineCompagnie]

Ha je comprends mieux, j'ai donc créé une

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
int facto(int* x){
 
	int y=1;
 
	for (int i = 1; i< x+1; i++){
 
		y = y*i;
	}
	x = y;
	return y;
 
}

Mais je ne peux plus faire la boucle à cause du test i< x+1 qui me signale une

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

invalid conversion from ‘int’ to ‘int*’

Je pense que l'idée de Matt_Hoston est vraiment chouette !

Tu n'as aucunement besoin de ré-implémenter l'algorithme pour chacune de ces formes d'appel. Une fois suffit. C'est uniquement la façon dont on transmet l'information aller et retour qui change, pas la manière de calculer la factorielle. Deux de ces trois fonctions peuvent invoquer la dernière, par exemple, qui, elle, effectuera le traitement.

Néanmoins, comment la mettre en place ?

[Matt_Houston]

Tout ce qu'on peut te dire ne peut rien t'évoquer puisque tu méconnais les bases du langage. Tu ne t'en sortiras pas en essayant des trucs au petit bonheur (on peut à la limite passer de C++ à Java de cette manière, mais pas l'inverse). Il faut que tu te plonges dans un cours de C++ pour en apprendre la grammaire, comme quelqu'un te l'a déjà conseillé sur un autre fil.