Compter des arguments

Version imprimable

je bloque sur un exercice qui me rend folle rrrrrr

coder la fonction de prototype
unsigned int size_x (char *), qui utiliserait l'accès indexé pour compter, puis retourner le nombre effectifs de caractères dans une chaîne quelconque passée en argument

j'ai essayé plusieurs code qui ne marche pas biensur:(
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <stdio.h> #include <stdlib.h> unsigned int size_x(str char *argv[]) { size_x (argv[]); return 0;} unsigned int size_x(char * argv) { int compteur = 0, k = 0; while (argv[k]) {compteur++ ; k++;} ; printf("%s : %i caractères\n", argv[1], size_x(argv[1])) ; }

16/09/2015, 15h59
ternel

ton pointeur en entrée est similaire à un tableau terminé par un 0 (=NULL)

Comme c'est un char*, cela signifie que ++ avance de sizeof(char), c'est à dire 1.
toi, ce qui t'intéresserait, c'est de compter les mots (groupe de caractères non blancs, séparés par des blancs).

il y a une difficulté: les blancs consécutifs.
Envisage d'utiliser is_space ou is_numalpha.

Maintenant, si tu cherches seulement la longueur d'une chaine, il s'agit de recoder la fonction strlen
Tu remarqueras que k et compteur ont la même valeur et le même type, et donc que l'un des deux est inutile.

Quel est le symptome qui te fait dire que ca ne marche pas?
16/09/2015, 16h03
l1informatique

Je suis débutante en C on n'a pas fais ce que tu me demande encore donc je dois utiliser que ce qu'on n'a fait pas plus
16/09/2015, 16h55
ChipsAlaMenthe

Salut à toi!
C'est quoi ton message d'erreur exactement? Ou bien ce que ça te retourne?
Moi il y a plusieurs choses qui me surprennent:
- Tu utilises le même nom pour les deux fonctions, même si le type des arguments sont différents, c’est pas la meilleure solution.
- Les deux fonctions s’appellent l’une l’autre, c’est une structure vraiment étrange.
- Ton compteur et ta variable k s’incrémentent en même temps tous les deux.

J'ai essyaé cette fonction

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <stdio.h>
#include <stdlib.h>
 
unsigned  int size_x(char *str)
 
int main ( int argc,  char* str[] )
 
{
 int compteur = 0;
  while (str[argc]) {compteur++ ;} ;
  printf("Argument %s :  Argument %ld\n", str[1], compteur);
 
 return 0;}

message d'erreur

Code:

1
2
3
4
5
6
7
8
9
10
11
-SVF1521A7EB:~$ ./compile c4.c
cx07.3.c: In function ‘size_x’:
cx07.3.c:8:1: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘{’ token
 {
 ^
cx07.3.c:13:2: error: expected ‘{’ at end of input
  return 0;}
  ^
cx07.3.c:13:2: warning: control reaches end of non-void function [-Wreturn-type]
  return 0;}
  ^

Déjà, au niveau de l'indentation et de la syntaxe il y a des problèmes.
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 <stdio.h> #include <stdlib.h> unsigned int size_x(str char *argv[]) { size_x (argv[]); return 0; } int main (int argc, char** argv) { int compteur = 0; while (argv[argc]) { compteur++ ; } printf("Argument %s : Argument %ld\n", argv[1], compteur); return 0; }
J'ai juste recopié ton code en enlever les potentielles fautes de syntaxe que j'ai pu voir.
Il te manque une condition de test dans le "main" pour vérifier que tu as bien des arguments passés en ligne de commande.

Ensuite ce que je ne comprends pas c'est à quel moment tu appelle size_x, car elle n'est jamais appelée.
Je ne comprend pas non plus ce que tu veux faire exactement, tu veux compter le nombre d'arguments? Compter le nombre de caractères par argument? Compter le nombre de caractère de tous les arguments confondus? Il nous faudrait une explication plus détaillée et explicite car le code est difficilement exploitable pour le comprendre. ^^

17/09/2015, 09h26
l1informatique

je dois coder une fonction qui prend en argument une chaîne de caractères et retourne le nombre de caractères.

Ex. :
size_x("essaye") => 6
size_x("Ceci est un argv.") => 17

mais je ne trouve pas :s

Essaie un truc du genre:

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
#include <stdio.h>
#include <stdlib.h>
 
unsigned int size_x(char argv[])
{
    int compteur = 0;
 
    while (argv[compteur] != '\0')
    {
        compteur++;
    }   
 
    return compteur;
}
 
 
int main (int argc,  char** argv)
{
    int compteur = 0;
 
    if (argc >= 1)
    {
        compteur = size_x(argv[1]);
        printf("La chaine : %s, contient %d caracteres.\n", argv[1], compteur);
    }
    else
    {
        printf("Aucune chaine de caracteres detectee\n");
    }
 
    return 0;
}

Dans la fonction "size_x", il y a un test avec le caractère '\0', qui correspond au caractère fin de chaine en C, qui est important.
Tu peux ainsi appeler ton programme comme ça:

./mon_prog "ma chaine de caracteres"

17/09/2015, 09h57
l1informatique

Merci c'est exactement ça mais je dois comprendre le code car j'ai du mal a comprendre "prototype" pour moi c'esrt mettre void ....
17/09/2015, 10h10
ChipsAlaMenthe
En gros, tu as plusieurs manières de déclarer tes fonctions en C. Tu peux mettre les fonctions en entier, comme je viens de te le faire plus haut. Mais tu peux aussi en déclarer un "prototype".
A quoi ça sert exactement? Ca peut servir pour plusieurs raisons, une étant: Si par exemple tu utilises une fonction "alpha", qui elle fait appelle à une fonction "omega", si jamais la fonction "omega" est implémentée APRES la fonction "alpha" dans le fichier, le compilateur ne comprendra pas, car tu auras fait appelle à une fonction "omega" qui n'est pas encore définie au moment où il rentre dans la fonction "alpha".

Par exemple, ce qui peut générer une erreur:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int alpha() { int compteur; compteur = omega(); return compteur; } int omega() { return 42; }
Etant donné que "omega" sera rencontré pour la première fois dans "alpha", il y a erreur. Pour palier à ce problème, soit tu déclare "omega" avant "alpha" comme ci-dessous:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int omega() { return 42; } int alpha() { int compteur; compteur = omega(); return compteur; }
Soit tu utilises le prototypage:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int alpha(); int omega(); int alpha() { int compteur; compteur = omega(); return compteur; } int omega() { return 42; }
Et le code ci-dessus ne génèrera plus d'erreurs ;). Tu y vois plus clair?
17/09/2015, 10h18
l1informatique

OUI, je vous remercie je vois maintenant c'est mieux expliquer :)

Bonsoir
Citation:
Envoyé par ChipsAlaMenthe
Essaie un truc du genre:
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 #include <stdio.h> #include <stdlib.h> unsigned int size_x(char argv[]) { int compteur = 0; (1)while (argv[compteur] != '\0') { compteur++; } return compteur; } int main (int argc, char** argv) { int compteur = 0; if (argc >= 1) { (2)compteur = size_x(argv[1]); printf("La chaine : %s, contient %d caracteres.\n", argv[1], compteur); } else { printf("Aucune chaine de caracteres detectee\n"); } return 0; }
Dans la fonction "size_x", il y a un test avec le caractère '\0', qui correspond au caractère fin de chaine en C, qui est important.
Tu peux ainsi appeler ton programme comme ça:
./mon_prog "ma chaine de caracteres"
Sauf erreur de ma part, il me semble que le code soit erroné, car chez moi si j'exécute le code source t'elle qu'il est écrit j'ai une erreur Segmentation fault: 11.
j'ai effectuer de différends teste d'exécution qui sont:
-> le programme avec aucun argument cela donne Segmentation fault: 11
-> le programme avec un argument mais qui n'est rien d'autre qu'un blanc cela donne Segmentation fault: 11
-> le programme avec un argument de type bonjours alors là le code fonction.

Hormis le problème du segment default, il y a aussi une erreur dans l'implémentation de votre algorithme
(1) je pense pour ma par qu'une boucle pour est mieux adapté qu'une boucle tant que, mais ce n'est juste qu'un avis.
(2) votre instruction est incorrect car on obtiendra qu'un seul argument et si ont fournis plus d'argument le reste sera ignoré a cause de la valeur qui a été fixer et qui lui sert de constante.
En appliquant quelque correction le code source pourrait être écrit de cette façon:
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 // // main.c // Test_C // // Created by sambia39 on 18/09/2015. // Copyright © 2015 Sambia39. GPLv3. // #include <stdio.h> #include <stdlib.h> /* Fonction qui fournit le nombre de caractère ce qui définit également la taille de la chaine */ int f_size_x( const char *p ){ int i = 0; for( i = 0; p[i] != '\0'; i++ ); return i; } /* Programme principale */ int main ( int argc, char **argv ){ int i = 0; if( argc > 1 ){ for( i = 1; i < argc; i++){ fprintf( stdout, "%d\t:%s\n", f_size_x(argv[i]), argv[i] ); } return EXIT_SUCCESS; } fprintf( stdout, "Aucun argument disponible\n" ); return EXIT_SUCCESS; }
à bientôt