Exemple 5-5 Trouver la moyenne de trois nombres. (identique à l'utilisation normale des variables)
Programme source :
#include <iostream>
using namespace std ;
int main()
{ float fun(float a, float b, float c);//Déclaration de fonction static float a[5] = { 87.5, 90, 100 } ; //Définir un tableau de type float et initialiser float ave; ave = fun(a[0], a[1], a[2]);//appeler la fonction fun() cout << ave << endl; } float fun(float a, float b, float c)//définition de la fonction { float sum, aver; sum = a + b + c; aver = sum / 3.0; return(aver); }
#include <iostream>
using namespace std;
int main()
{
float fun(float a, float b, float c);//函数声明
static float a[5] = { 87.5, 90, 100 };
//定义一个 float 型数组并初始化
float ave;
ave = fun(a[0], a[1], a[2]);//调用 fun（）函数
cout << ave << endl;
}
float fun(float a, float b, float c)//函数定义
{
float sum, aver;
sum = a + b + c;
aver = sum / 3.0;
return(aver);
}résultat:
En fait, changer a[5] en a[3] n'affectera pas le résultat, que vous n'écriviez pas static ou que vous écriviez la plage si large .
C'est juste que nous écrivons généralement comme ça pour des raisons d'assurance, et parfois nous éviterons naturellement des problèmes inutiles
Dans le même temps, la précédente "somme = a + b + c ; moyenne = somme / 3,0 ;" peut également être abrégée en "moyenne = (a + b + c) / 3,0 ;" en une seule étape.
Les exemples pratiques sont les suivants :
#include <iostream>
using namespace std;
int main()
{
float fun(float a, float b, float c);//函数声明
float a[3] = { 87.5, 90, 100 };
//定义一个 float 型数组并初始化
float ave;
ave = fun(a[0], a[1], a[2]);//调用 fun（）函数
cout << ave << endl;
}
float fun(float a, float b, float c)//函数定义
{
float aver;
aver =( a + b + c) / 3.0;
return(aver);
}résultat:
Exemple 5-6 Trouver la moyenne de trois nombres.
#include <iostream>
using namespace std ;
int main()
{ float fun2(float x[3]);//Déclaration de fonction float a[3] = { 87.5,90,100 } ; //Définir le tableau et initialiser*/ float ave ; ave = fun2(a);//Appelle la fonction et utilise le nom du tableau comme paramètre*/ cout << ave << endl; } float fun2(float x[3]) //Définition de la fonction, le paramètre formel est un tableau*/
{ somme flottante, moyenne ; somme = x[0] + x[1] + x[2] ; moyenne = somme / 3,0 ; retour (moyenne); }
#include <iostream>
using namespace std;
int main()
{
float fun2(float x[3]);//函数声明
float a[3] = { 87.5,90,100 }; //定义数组并初始化*/
float ave;
ave = fun2(a);//调用函数并将数组名作为参数*/
cout << ave << endl;
}
float fun2(float x[3]) //函数定义，形式参数为数组*/
{
float sum, aver;
sum = x[0] + x[1] + x[2];
aver = sum / 3.0;
return(aver);
}Le processus de transfert est le suivant (pour la description du processus, reportez-vous (suivez) au paragraphe précédant P87 Introduction Exemple 5-6) :
Le résultat est le même que ci-dessus :
Livre P87 :
La première adresse du tableau coïncide, et les éléments suivants sont stockés dans la mémoire dans le même ordre que la même adresse de stockage de données.
Par conséquent, le nombre d'éléments du tableau de paramètres réel ne doit pas être inférieur à celui du paramètre formel
Oh? Cela semble douteux (à vérifier) :
Lorsque le jeu de paramètres réel comporte moins d'éléments que les paramètres formels :
#include <iostream>
using namespace std;
int main()
{
float fun2(float x[3]);//函数声明
float a[3] = { 87.5,90 }; //定义数组并初始化*/
float ave;
ave = fun2(a);//调用函数并将数组名作为参数*/
cout << ave << endl;
}
float fun2(float x[3]) //函数定义，形式参数为数组*/
{
float sum, aver;
sum = x[0] + x[1] + x[2];
aver = sum / 3.0;
return(aver);
}Si vous supprimez simplement un nombre, le résultat final équivaut à traiter a[2] comme 0 pour trouver la moyenne de trois nombres.
En d'autres termes, rien ne se passera comme ça, et le programme ne se trompera toujours pas.
#include <iostream>
using namespace std;
int main()
{
float fun2(float x[3]);//函数声明
float a[2] = { 87.5,90 }; //定义数组并初始化*/
float ave;
ave = fun2(a);//调用函数并将数组名作为参数*/
cout << ave << endl;
}
float fun2(float x[3]) //函数定义，形式参数为数组*/
{
float sum, aver;
sum = x[0] + x[1] + x[2];
aver = sum / 3.0;
return(aver);
}Mais si nous changeons le nombre spécifique d'éléments du paramètre réel en a[2], alors le résultat semble un peu étrange :
Selon l'étudiant Yang Huan :
La situation la plus probable est :
Parce que l'espace mémoire du paramètre réel n'est que de 2 bits à ce moment
À ce moment, le système attribuera une valeur aléatoire au troisième paramètre formel , et il n'est pas rare que des résultats apparaissent à ce moment.
Et lorsque le jeu de paramètres réel contient plus d'éléments que les paramètres formels :
#include <iostream>
using namespace std;
int main()
{
float fun2(float x[3]);//函数声明
float a[5] = { 5,6,7,8,9}; //定义数组并初始化*/
float ave;
ave = fun2(a);//调用函数并将数组名作为参数*/
cout << ave << endl;
}
float fun2(float x[3]) //函数定义，形式参数为数组*/
{
float sum, aver;
sum = x[0] + x[1] + x[2];
aver = sum / 3.0;
return(aver);
}Résultat : 6
C'est-à-dire que lorsque le nombre d'éléments du groupe de paramètres réels est supérieur à celui des paramètres formels, la valeur par défaut de la fonction appelle les premiers paramètres (ici, seule la valeur moyenne des trois premiers paramètres réels est calculée )
Si la valeur d'un élément de tableau est modifiée dans la sous-fonction, la valeur de l'élément correspondant du groupe de paramètres réel dans la fonction appelante sera également modifiée en conséquence.
La modification de conception sur le programme ci-dessus prouve la conclusion comme suit :
#include <iostream>
using namespace std ;
int main()
{ float fun2(float x[3]);//Déclaration de fonction float a[3] = { 87.5,90,100 } ; //Définir le tableau et initialiser*/ float ave ; ave = fun2(a);//Appelez la fonction et utilisez le nom du tableau comme paramètre*/ cout << ave << endl; cout << a[1] << endl; } float fun2(float x[3 ]) / /Définition de la fonction, le paramètre formel est un tableau*/
{ somme flottante, moyenne ; x[1] = 0 ; somme = x[0] + x[1] + x[2] ; moyenne = somme / 3,0 ; retour (moyenne); }
résultat:
Exemple 5-7 Utilisez une fonction pour résoudre la valeur maximale de l'exemple 5-4 et utilisez un tableau comme paramètre.
Programme source :
#include <iostream>
en utilisant l'espace de noms std ;
int main()
{ int max_value(int array[][4]); int a[3][4] = { (11,32,45,67),(22,44,66,88),(15,72,43,37)} ; cout << "la valeur max est " << max_value(a) << endl; renvoie 0 ; } int max_value(int array[][4]) { int je, j, max ; max = tableau[0][0] ; for (i = 0; i < 3; i++) for (j = 0; j < 4; j++) if (array[i][j] > max) max = array[i][j]; maximum de retour ; }
#include <iostream>
using namespace std;
int main()
{
int max_value(int array[][4]);
int a[3][4] = { (11,32,45,67),(22,44,66,88),(15,72,43,37)};
cout << "max value is " << max_value(a) << endl;
return 0;
}
int max_value(int array[][4])
{
int i, j, max;
max = array[0][0];
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++)
if (array[i][j] > max) max = array[i][j];
return max;
}
J'écris:
Utilisez des éléments de tableau comme paramètres de fonction : je dois déclarer 12 paramètres formels de cette manière, ce qui est trop gênant, nous allons donc l'omettre temporairement ici.
Utilisez les noms de tableaux comme arguments de fonction :
Écrit à l'origine :
#include <iostream>
using namespace std;
int main()
{
int max_value(a[int x][int y]);
int a[3][4] = { (11,32,45,67),(22,44,66,88),(15,72,43,37) };
cout << "max value is " << max_value(a[3][4]) << endl;
return 0;
}
int max_value(int a[int x][int y])
{
int x,y, max;
for (x = 0; x < 3; x++)
for (y = 0; y < 4; y++)
if (a[x][y] > max) max = a[x][y];
return max;
}
Selon l'exemple 5-6 du livre, suivez le chat et dessinez le tigre, et enfin modifiez le programme ci-dessus pour :
#include <iostream>
using namespace std;
int main()
{
int max(int a[3][4]);
int a[3][4] = { (11,32,45,67),(22,44,66,88),(15,72,43,37) };
cout << "最大值为：" << max(a[3][4]) << endl;
return 0;
}
int max(int a[3][4])
{
int x,y,max=0;
for (x = 0; x < 3; x++)
for (y = 0; y < 4; y++)
if (a[x][y] > max)
max = a[x][y];
return max;
}
Mais le résultat est toujours faux : il devrait être :
#include <iostream>
en utilisant l'espace de noms std ;
int main()
{ int max(int a[3][4]); int a[3][4] = { (11,32,45,67),(22,44,66,88),(15,72,43,37) } ; cout << "最大值为：" << max(a) << endl; renvoie 0 ; } int max(int a[3][4]) { int x, y, max=0 ; pour (x = 0; x < 3; x++) pour (y = 0; y < 4; y++) si (a[x][y] > max) max = a[x][y]; maximum de retour ; }
Les principaux problèmes de l'ensemble du processus sont les suivants :
Ni la longueur ni la structure de données du paramètre réel ne sont définies au moment de la déclaration et de la définition.
Mes questions (doutes) lors de la modification :
1. Le livre ne dit-il pas qu'il n'est pas important de définir la longueur du paramètre formel ? Ce que je n'ai pas défini ici, ce sont tous des paramètres formels, qu'est-ce qui ne va pas ?
2. En ce qui concerne la longueur du paramètre formel, puisque la longueur est requise, pourquoi :
cout << "La valeur maximale est :" << max(a) << endl ;
cela ne déclare pas la longueur, mais c'est
cout << "La valeur maximale est : " << max(a[3][4]) << endl;
pas possible ?
Réponses sur pourquoi :
1. Il n'est en effet pas nécessaire d'écrire la longueur du paramètre formel, mais ce n'est pas la raison d'écrire (int a[int x][int y]) dans la définition et la déclaration de la fonction :
x et y sont utilisés pour s'auto-incrémenter à chaque cycle pour traiter le bit suivant
Il n'est pas ici pour briser la limite d'exigence de chaque ligne et colonne du groupe de paramètres formels
Même si la structure de tableau de ce groupe de paramètres formels peut être flexible et modifiable, le livre indique que "le groupe de paramètres formels peut ne pas définir la longueur"
Mais le livre n'a pas dit "Le groupe de paramètres formels ne peut pas définir la largeur et d'autres dimensions" ah
C'est-à-dire:
D'une part, le groupe de paramètres formels ne peut pas définir la longueur ; d'autre part, le groupe de paramètres formels ne peut pas oublier de définir la largeur et d'autres dimensions
Ou:
Le groupe de paramètres formels n'a pas besoin de définir la longueur, mais doit définir la largeur et d'autres dimensions
2. Pourquoi seul a peut être rempli entre parenthèses (à l'intérieur) lors de l'appel de la fonction max mais pas a[3][4] :
Si vous remplissez a[3][4] entre parenthèses
Il est très probable (forte probabilité) que a[3][4] identifié par le système soit l'élément de tableau a[3][4] plutôt que le tableau entier de a[3][4]
Élément de tableau a[3][4] : l'élément de tableau spécifique dans la troisième ligne et la quatrième colonne dans a[3][4]
De plus, même si a représente tout le tableau, pour le système, ce n'est qu'une chaîne de nombres
Ce que le système veut, c'est une variable ou une constante int, pas une chaîne de nombres
Et si vous remplissez a entre parenthèses :
a satisfait "est une constante int", et est la première adresse mémoire du premier élément du tableau
Il n'y a pas d'erreur grammaticale, et l'adresse peut également être transmise, ce qui est naturellement le bon choix
P88：
Vous pouvez modifier l'en-tête de la fonction max_value dans les situations suivantes pour observer la situation de compilation :
Dessinez le tableau suivant en fonction de la situation réelle :
| int valeur_max(tableau int[][]) | 0 |
| int valeur_max(tableau int[3][]) | 0 |
| int valeur_max(tableau int[3][4]) | 1 |
| int valeur_max(tableau int[10][10]) | 0 |
| int valeur_max(tableau int[12]) | 0 |
1 : opération réussie ; 0 : rapport d'erreur ;
La conclusion ci-dessus prouve sans aucun doute une fois de plus que :
Le groupe de paramètres formels n'a pas besoin de définir la longueur, mais doit définir la largeur et d'autres dimensions
Extensions supplémentaires :
Pourquoi
| int valeur_max(tableau int[10][4]) | 1 |
| int valeur_max(tableau int[3][10]) | 0 |
?
Les raisons sont les suivantes:
Pour plus de détails, veuillez consulter :