"too few arguments" à l'initialisation d'une fonction

Version imprimable

Bonjour,

Je commence le C++, et avec les quelques base que j'acquers, je fais quelques petits essais...

Voilà l'un d'eux: Le but est de calculer tous les nombres premiers jusqu'au nombre entré par l'utilisateur...

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
 
//
//
//
// - Template -
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
 
 
int limite;
int base[512];
int tested;
int result;
 
 
// Déclaration du prototype
 
int test(int tested , int base[]);
 
 
int main(int nNumberofArgs, char* pszArgs[])
{
    // Enumère les nombre de 1 à limit.
 
 
 
 
        // Demande à l'utilisateur jusqu'à quel nombre il veut aller
 
        cout << "Entrez la limite : ";
        cin >> limite;
 
        tested = 2;
 
        for (int k=0;k!=limite;k++)
        {
        result = test(tested);
 
        cout << result << endl;
 
        tested++;
        }
 
 
 
}
 
    // Pause
 
    system("Pause");
    return 0;
}
 
 
 
// Teste le nombre en cours
 
 
int test(int tested , int base[])
{
 
int n=0;
 
 
for (;n!=5;)
{
 
 
    // Ajoute le nombre testé à base s'il est premier
 
    if (tested%base[n]!=0 )
    {
                    base[n] = tested;
 
                    return tested;
 
 
 
                    break;
 
                    }
 
                    n++;
 
                    continue;
                    }
 
}

Le compilateur me dit "too few arguments to fonction 'in test(int, int*, int)'" à la ligne 19...

Quelqu'un pourrait m'indiquer en quoi c'est faux? et éventuellement s'il y a d'autres endroits ou le programme pourrait ne pas fonctionner?

Merci beacoup pour votre aide, et bonne année à tous!

06/01/2008, 21h05
yan

Bonjour,

Citation:

Envoyé par mr:titi7

Le compilateur me dit "too few arguments to fonction 'in test(int, int*, int)'" à la ligne 19...

??? Tu ne te trompe pas dans l'erreur???
sinon cette ligne ne marchera pas :

Code:

result = test(tested);

car test est déclaré comme

Code:

int test(int tested , int base[]);

il manque le deuxième paramètre
06/01/2008, 22h37
koala01

Salut,

Le compilateur se plaint tout simplement que le nombre d'arguments passés à la fonction n'est pas le même que le nombre d'argument attendu par la fonction (la traduction "litérale" de l'erreur est "trop peu d'arguments passés à la fonction 'nom de la fonction'")

Mongaulois ==> non, c'est bien l'erreur qui doit être gérée :D le compilateur se plaint d'avoir un seul argument là où deux sont attendu par le prototype de la fonction :D

mr:titi7==> Pour compléter l'information, en C++, il existe une classe vector, disponible par inclusion du fichier d'en-tête <vector> dans l'espace de nommage std qui permet de gérer bien mieux les tableaux que ce qui se fait "classiquement" en C...

L'utilisation de cette classe (ainsi que de toutes celles que l'on retrouve dans la S(T)L d'ailleurs) est fortement préférable à toute mise en oeuvre généralement rencontrées en C ;)

Qio,

Il faudrait soigner un peu la présentation du code, cela te permettrait par exemple de voir du code inutile :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for (;n!=5;)
{
    // Ajoute le nombre testé à base s'il est premier
 
    if (tested%base[n]!=0 )
    {
        base[n] = tested;
        return tested;
        break; // on ne passe jamais ici, puisque placé juste après un return
    }
 
    n++; // pourquoi mettre ça ici, la syntaxe de la boucle for prévoit une place pour ça
    continue; // inutile, puisque derrnière instruction du corps de boucle.
}

07/01/2008, 00h30
yan

Citation:

Envoyé par koala01

Mongaulois ==> non, c'est bien l'erreur qui doit être gérée :D le compilateur se plaint d'avoir un seul argument là où deux sont attendu par le prototype de la fonction :D

ben non, enfin a moitié...

Citation:

"too few arguments to fonction 'in test(int, int*, int)'" à la ligne 19

1- c'est pas a la ligne 19
2- int test(int tested , int base[]); il n'y as pas de troisieme paramètre
3- oui il manque un argument
07/01/2008, 01h27
koala01

En fait, cette erreur est *relativement* imprécise...

Car, l'un dans l'autre, on peut considérer que c'est le prototype qui fait fois, mais, dans quelle mesure l'appel la fonction n'est elle pas plus cohérente si on lui fournit plus d'argument que ce que demande le prototype (meme si, dans ce cas là, c'est qu'il y a eu un problème lorsque l'on a réfléchi au comportement à donner à cette fonction ;) :P)

En plus, je *crois* que l'erreur reste la meme avec un prototype demandant deux arguments et en recevant trois qu'avec un prototype demandant trois arguments et en recevant deux (too few) ...

Merci les gens!

J'ai regardé ce que je pouvais faire pour renvoyer autant de variables à la fonction que ce que je déclarais.

n et base sont inutiles depuis main, puisque utilisés depuis test uniquement.

Mais maintenant, j'ai un autre problème... :(

Les nombres ne sont pas correctement testés, puisque base[] ne reste pas entre deux appels de test. J'ai donc déclaré base[] comme static, pour qu'elle reste entre chaque appel. Mais visiblement, ça fait planter le programme...

J'ai lancé en debug, et l'erreur semble être à la ligne 74... Il me dit qu'il peut pas voir les variables n et base[]... Pourquoi? Elles sont pourtant déclarés dans la fonction et précédemment... Si vous pouviez m'expliquer...^^

Voilà le code actuel:
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 // // // Affiche les nombres premiers jusqu'à la limite // donnée par l'utilisateur. #include <cstdio> #include <cstdlib> #include <iostream> using namespace std; int limite; int tested; int result; // Déclaration du prototype int test(int tested); int main(int nNumberofArgs, char* pszArgs[]) { // Enumère les nombre de 1 à limit. // Demande à l'utilisateur jusqu'à quel nombre il veut aller cout << "Entrez la limite : "; cin >> limite; tested = 2; for (int k=0;k!=limite;k++) { result = test(tested); cout << result << endl; tested++; } // Pause system("Pause"); return 0; } // Teste le nombre en cours int test(int tested) { static int base[5]; int n=0; for (int n=0;n!=4;n++) { // Ajoute le nombre testé à base s'il est premier if (tested%base[n] != 0 ) { base[n] = tested; return tested; } } }

10/01/2008, 08h22
poukill

Citation:

Envoyé par mr:titi7

Les nombres ne sont pas correctement testés, puisque base[] ne reste pas entre deux appels de test. J'ai donc déclaré base[] comme static, pour qu'elle reste entre chaque appel. Mais visiblement, ça fait planter le programme...

Si tu veux que base soit identique entre deux appels de fonction, il te faudra le passer en paramètre à ta fonction depuis le main qui chapote le tout, ou bien alors le déclarer comme variable globale...

Par contre, base ne peut contenir que 5 éléments, je ne vois pas comment tu vas y stocker 350 nombres premiers ! ;)
Pour résoudre ce problème, utilise std::vector comme celà t'a déjà été proposer...

A +
11/01/2008, 16h18
mr:titi7

Merci, je vais essayer de la mettre dans main, effectivement...

Mais le truc de std::vector, je connais pas du tout, et je sais pas comment ça marche, j'essaierai quand j'aurai appris... je m'y mettrai après avoir fini ça...^^

En fait, c'était pas ça qui faisait planter le programme, maintenant, j'ai déclaré base[] comme globale, et il y a toujours ce bug à la ligne 74...

Je remets le code comme il est actuellement:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
//
//
//
// - Template -
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
 
 
int limite;
int base[10];
int tested;
int result;
 
 
// Déclaration du prototype
 
int test(int tested);
 
 
int main(int nNumberofArgs, char* pszArgs[])
{
    // Enumère les nombre de 1 à limit.
 
 
 
 
        // Demande à l'utilisateur jusqu'à quel nombre il veut aller
 
        cout << "Entrez la limite : ";
        cin >> limite;
 
        tested = 2;
 
        for (int k=0;k!=limite;k++)
        {
        result = test(tested);
 
        cout << result << endl;
 
        tested++;
        }
 
 
 
 
 
    // Pause
 
    system("Pause");
    return 0;
}
 
 
 
// Teste le nombre en cours
 
 
int test(int tested)
{
 
 
 
 
 
 
for (int n=0;n!=10;n++)
{
 
 
    // Ajoute le nombre testé à base s'il est premier
 
    if (tested%base[n] != 0 )
    {
                    base[n] = tested;
 
                    return tested;
 
 
 
                    }
 
 
 
                    }
 
}

12/01/2008, 14h00
mr:titi7

C'est bon, j'ai compris pourquoi ça plantait!

11e commandement: Tu ne diviseras pas par 0.

Je comprends pourquoi: ça fait planter windows... ^^

Comme base était par défaut 0 à chaque case, faire "tested%0" était suicidaire...

Mais maintenant, tout fonctionne parfaitement! :D

Merci à tous!

Ceci dit, le deuxième commandement, c'est

Citation:

les variables globales, c'est mal

, et le troisième du C++ c'est

Citation:

préfère les classes conteneurs à leur équivalent codé main "C style"

Pour répondre au fait que tu ne connais pas std::vector, on peut tout simplement dire que ca regroupe tous les avantages des tableaux classiques, sans en avoir les inconvéninants...

A savoir:

Il est capable de maintenir en mémoire n'importe quel nombre d'éléments
Il connait en permanence le nombre d'élément qu'il contient (tu te contente de le passer en argument, et la taille est d'office connue ;))
Il s'occupe lui même de gérer la mémoire pour éviter les problèmes
Il fournit un acces au élément en O=1
Il permet d'ajouter et/ou de retirer des éléments n'importe où: au début, à la fin, voir meme entre deux éléments (le retrait d'éléments peut même s'effectuer sur une plage donnée: du 10eme au 20eme)

Son utilisation de base est relativement simple:
Il "suffit" d'nclure le fichier d'en-tete (standard) <vector>

La déclaration d'un objet de type vector se fait sous la forme de

Code:

std::vector<Type_d_elements_A_contenir> lenom;

ou, si tu a mis la directive using namespace std; sous la forme de

Code:

vector<Type_d_elements_A_contenir> lenom;

L'ajout d'un élément en fin de tableau se fait sous la forme de

Code:

lenom.push_back(la_variable_a_ajouter);

L'ajout d'un élément partout ailleurs se fait sous la forme de

Code:

lenom.insert(lenom.begin()+position);

Le retrait du dernier élément se fait sous la forme de (avec récupération du dernier élément)

Code:

lavar_qui_recupere=lenom.pop_back();

l'obtention du dernier élément (sans suppression de l'élément)peut se faire sous la forme de

Code:

lavar_qui_recupere=lenom.back();

tu peux obenir n'importe quel élément sous la forme, classique, de

Code:

lavar_qui_recupere=lenom[index_voulu];

La suppression (sans récupération de la valeur) d'un élément peut se faire sous la forme de

Code:

lenom.erase(lenom.begin()+index);

la suppression d'une plage d'éléments (par exemple du 10eme au 20eme) peut se faire sous la forme de
lenom.erase(lenom.begin()+index_depart,lenom.begin()+index_fin);
Si tu veux vider l'ensemble du tableau, tu peux le faire sous la forme de

Code:

lenom.clear();

sois attentif au fait que, si la mémoire des éléments contenus a été allouée dynamiquement, tu est responsable de la libération de la mémoire, ce qui prendrait la forme de
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 26 27 28 29 30 #include <vector> void fonctionInsertion(std::vector<MaClass*>& tab) { tab.push_back(new MaClass()); /* ou * MaClass* obj=new MaClass(); * tab.push_back(obj); */ } void Liberation(std::vector<MaClass*>& tab) { for(size_t i=0;i<tab.size();i++) { delete tab[i]; /* libere la mémoire allouée à l'élément [i]*/ } tab.clear(); /* vide le tableau } int main() { std::vector<MaClass*> tab; /* juste un exemple, hein ;) */ for(size_t i=0;i< variable;i++) { fonctionInsertion(tab); } /*...*/ Liberation(tab); return 0; }

12/01/2008, 19h32
mr:titi7

Ok, merci pour toutes ces infos, je vais essayer pareil avec le type vector... (allez, un coup de prise de tête...^^)

Mais y'a juste un truc que j'ai pas bien compris... Tu dis que je suis responsable de vider la mémoire... c'est à dire que sinon ça reste stocké même après l'arrêt du programme? c'est mortel, non? :s
12/01/2008, 20h17
Davidbrcz

Nan pas vraiment.

Quand un programme est fermé,toute la mémoire est rendu à l'OS (ya pas le choix).

Par contre, tant que ton programme n'est pas fermé,la mémoire alloué dynamiquement est sous ta responsabilté Et il faut bien faire attention à ne pas en perdre sous peine de crash assuré.

Citation:

Envoyé par mr:titi7

<snip>
Mais y'a juste un truc que j'ai pas bien compris... Tu dis que je suis responsable de vider la mémoire... c'est à dire que sinon ça reste stocké même après l'arrêt du programme? c'est mortel, non? :s

Non, la fin d'un programme libère automatiquement la mémoire utilisée par ce programme, du moins, avec les OS actuels ;)

Ce qui se passe, c'est que, bien souvent, dans le cadre d'application un peu plus importante que le simple "hello world !" présenté pour apprentissage, on ne peut jamais être sur au moment de la conception du nombre d'éléments d'un type donné dont on aura besoin (du moins, dés le moment où l'on a déterminé avec précision qu'il y en aura plus d'un :D)

Au cours de l'application, il n'est pas rare de voir, dans une situation donnée, mais de manière répétée, qu'il faut créer un nouvel élément, et pour certaines utilisation particulière, l'allocation dynamique de mémoire est la seule possiblité envisageable :P

Seulement, et de la même manière, il est très rares que ces éléments créés pour une raison précise doivent survivre jusqu'à la fin de l'application, et il n'est donc pas rare que l'on décide de "supprimer" un élément devenu inutile.

Or, le langage estime que, si tu a demandé explicitement d'être responsable de l'occupation de la mémoire pour un élément, c'est à toi que revient de choisir le moment où cette mémoire devra être libérée (ce qui est logique, quelque part, non :question:)

Le "système", lui, garde une trace de toute la mémoire que tu lui a demandé (mais ne controle absolument pas ce que tu en fait), et sait donc à tout moment la mémoire utilisée par ton application, pour éviter de permettre une autre allocation de la mémoire qui t'est déjà allouée
Et, si tu "perd" toute référence à de la mémoire allouée dynamiquement, le système n'en a "rien à foutre": c'est de la mémoire qu'il a donné à l'application :P
Code:

1 2 3 4 5 6 7 8 9 10 int *ptr; /* cela aurait très bien pu être n'importe quel type ;) */ ptr= new int[20]; /* (1) je demande la place pour mettre 20 entiers */ /*...*/ ptr=new int[50]; /* Je demande la place pour mettre 50 entiers, et le * système me la donne... mais j'ai perdu toute référence à la * mémoire allouée à mes 20 entiers en (1). * La mémoire allouée en (1) devient donc inutilisable jusqu'à * l'arret du programme */
Nous venons d'organiser une magnifique "fuite mémoire" (memory leak en anglais), et, ce que l'on a eu si facile à faire dans un style fort proche du C est encore presque plus facile à faire avec les conteneurs de la STL:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <vector> int main() { std::vector<int*> tableau; /* on demande combien d'ajout (N) devront etre fait ;), puis */ for (size_t i=0;i<n;i++) { /* on demande combien d'entiers (m) doivent etre géré pour tableau[i] */ tableau.insert(new int[m]);/*cela ne pose aucun problème: je garde * dans tableau l'acces à tous les éléments alloués */ } /*...*/ /* on demande quel élément de tableau supprimer */ tableau.erase(tableau.begin()+index);/* AIE... on vient de perdre toute * référence pour retrouver la mémoire allouée * pour cet élément */ /*...*/ return 0; }
Selon la quantité de mémoire dont dispose le système, la fréquence avec laquelle de telles fuites de mémoire apparaissent et la quantité de mémoire perdue à chaque fois, cela prendra peut etre 3 minutes (ou moins), 3 mois ou 3 ans (ou plus), mais, tôt ou tard, le système finira par... ne plus pouvoir donner de mémoire à l'application quand elle en demandera :P

Pire, il finira par ne plus pouvoir donner de mémoire à n'importe quelle application, et c'est donc l'ensemble du système qui peut devenir instable (et nécessiter jusqu'à un redémarrage) alors que, tant que ce point néfaste n'est pas atteint, il aurait suffit de simplement arreter ton application pour que tout rentre dans l'ordre ;)