Convertir tolower - toupper.

Version imprimable

Bonjour

J'essaie de converir un texte en minuscul s'il est en majuscul, et vice versa, mais mon code ne convertit qu'en un seul sens, en fonction si c'est toupper ou tolower qui vient en premier.
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> main(){ char text[80]; char texti[80]; int i, cpt; for(i=0; (text[i]=getchar())!='\n'; i++) cpt=i; for(i=0; i<=cpt; i++) if(tolower(text[i])) putchar(toupper(text[i])); else if (toupper(text[i])) putchar(tolower(text[i])); system("PAUSE"); }

26/08/2007, 19h18
Gruik

Salux,

Que voulais tu faire avec "if(tolower(text[i]))" ?
ça n'a pas de sens :p
Tu voulais je suppose savoir si c'était une minuscule.. dans ce cas, la condition suivante devrait suffir : "text[i] >= 'a' && text[i] <= 'z'"

Aussi, il faut voir si tu veux gérer les caractères accentués latins.. (et par la meme occasion voir dans quel encodage est ton texte d'entrée)
26/08/2007, 19h22
aoyou

Citation:

RETURN VALUES
If the argument is an upper-case letter, the tolower() function returns
the corresponding lower-case letter if there is one; otherwise the argu-
ment is returned unchanged.

tolower te retournera toujours quelque chose de vrai au sens du if (sauf si tu lui passes 0 mais ce n'est pas une lettre).

Il faut que tu regardes si ton caractère est compris entre 'a' et 'z' (ou entre 'A' et 'Z').
26/08/2007, 19h28
Linu6

..humm, pourtant pour vérifier si une entrée est de type char ou pas on peut recourir à la formulation suivante:

if(isalpha(text[i])
....

Si je ne m'abuse, dans ce cas le test foncionne non?
26/08/2007, 19h45
gl

Citation:

Envoyé par Gruik

Tu voulais je suppose savoir si c'était une minuscule.. dans ce cas, la condition suivante devrait suffir : "text[i] >= 'a' && text[i] <= 'z'"

Pas terrible. Et si dans le charset utilise, les lettres ne dont pas contigue

Citation:

Envoyé par Linu6

..humm, pourtant pour vérifier si une entrée est de type char ou pas on peut recourir à la formulation suivante:

if(isalpha(text[i])
....

Si je ne m'abuse, dans ce cas le test foncionne non?

Cette fonction indique si il s'agit d'un caractere ou non, pas si il s'agit d'une majuscule ou d'une minuscule.

Pour connaitre la casse d'une lettre il existe les fonctions isupper et islower
26/08/2007, 19h50
Gruik

Citation:

Envoyé par gl

Pas terrible. Et si dans le charset utilise, les lettres ne dont pas contigue

Oui mais plus bas je déclarais vaguement que ça dependait de l'encodage http://blam.be/forum/images/smiles/capello.gif
Et puis c'est plutot rare les encodages qui sont pas à base d'ascii

Citation:

Pour connaitre la casse d'une lettre il existe les fonctions isupper et islower

Jles avais oubliées celles là tiens :king:
Du coup, si on veut gérer les caractères accentués yaura qu'a changer la locale
26/08/2007, 19h58
Linu6

Citation:

Envoyé par gl

Pour connaitre la casse d'une lettre il existe les fonctions isupper et islower

;)
J'étais sur qu'il y avait une methode testant la case à base de upper ~ lower.., mais j'avais oubliais la formulation exacte!
:oops:

En ce qui concerne la saisie, affecter la valeur retournée par getchar() à une variable de type char n'est pas conseillé. Sinon mes commentaires sont dans le code (je suppose que tu n'a pas de caractères spéciaux, e.g. accentués, à traîter):

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
#include <stdio.h>
#include <stdlib.h>
/* -TC- tolower(), toupper(, islower() et isupper() sont déclarées dans le
   fichier d'en-tête standard ctype.h
 */
#include <ctype.h>
 
/* -TC- ATTENTION: la fonction main retourne un entier de type int, toujours! */
int main(void)
{
    /* -TC- Personnellement, j'initialise toujours un tampon texte de cette
       manière
    */
    char text[80] = {0};
    /* -TC- Attention, getchar() retourne un entier de type int et non un char */
    int c;
    int i;
    int cpt = 0;
 
    /* -TC- affichage de l'invite et vidange du tampon de sortie */
    printf("Entrez un mot: ");
    fflush(stdout);
 
    /* -TC- Saisie caractère par caractère */
    for (i = 0; i < sizeof text - 1 && (c = getchar()) != '\n' && c != EOF; i++)
    {
        text[i] = c;
        cpt++;
    }
    /* -TC- Si c est différent de '\n' ou EOF, c'est que le tampon text est plein.
       On s'empresse d'afficher un message d'avertissement et de le vider le 
       tampon de l'entrée standard.
    */
    if (c != '\n' && c != EOF)
    {
        fprintf(stderr, "Buffer full, your entry has been truncated...\n");
 
        while ((c = getchar()) != '\n' && c != EOF)
        {
            continue;
        }
    }
 
    /* -TC- Attention, ton code présente des erreurs à ce niveau. Ta condition
       d'arrêt est fausse. Par ailleurs, if (tolower(text[i])) est toujours
       vraie à moins que text[i] soit le caractère nul. Je pense que tu voulais
       utiliser islower() et isupper() */
    for (i = 0; i < cpt; i++)
    {
        if (islower(text[i]))
        {
            putchar(toupper(text[i]));
        }
        else
        {
            putchar(tolower(text[i]));
        }
    }
 
    return EXIT_SUCCESS;
 
}

Thierry

26/08/2007, 20h09
Thierry Chappuis

Citation:

Envoyé par Linu6

;)
J'étais sur qu'il y avait une methode testant la case à base de upper ~ lower.., mais j'avais oubliais la formulation exacte!
:oops:

D'où l'utilité d'avoir une bonne doc à portée de main...

Thierry
26/08/2007, 20h32
Linu6

Merci a vous tous :love:

Citation:

D'où l'utilité d'avoir une bonne doc à portée de main...

On n'est pas moins bien servi ici, sans pour autant dépasser les bornes.
en tout cas, avec tes commentaires j'ai appris bien plus en 1 minute, qu'en un mois avec des "livres de références"

:lahola:
26/08/2007, 20h51
Linu6

En fait dans l'extrait ci-dessous, je ne vois ni l'endroit où on a défini le EOF..ni son utilité. (..mais peut être par inexpérience").

En quoi se maintenir à un simple "c = getchar()) != '\n' " est il insuffisant?

Code:

for (i = 0; i < sizeof text - 1 && (c = getchar()) != '\n' && c != EOF; i++)

:oops: :mrgreen:
26/08/2007, 20h59
gl

Citation:

Envoyé par Linu6

En fait dans l'extrait ci-dessous, je ne vois ni l'endroit où on a défini le EOF..ni son utilité. (..mais peut être par inexpérience").

En quoi se maintenir à un simple "c = getchar()) != '\n' " est il insuffisant?

EOF permet d'indiquer que l'a fin du fichier est atteinte. Ce qui est indispensable si l'entree standard est un fichier et non la console (dans la plupart des shell, le caractere < permet une telle redirection).
Il est egalement possible depuis une console d'indiquer une fin de fichier (generalement avec les touches Ctrl + D si je ne me trompe pas)
26/08/2007, 21h02
gl
Citation:
Envoyé par Thierry Chappuis

Code:

1 2 3 4 5 /* -TC- Personnellement, j'initialise toujours un tampon texte de cette manière */ char text[80] = {0};
Personnellement, s'il s'agit d'une chaine de caractere, j'ai une preference pour char text[80] = ""; qui revient strictement au meme et correspond mieux a une vision chaine de caracteres.
26/08/2007, 22h02
Linu6

je me demande si on a le drot de faire:

Code:

char text[80]=NULL

:roll:
26/08/2007, 22h12
Thierry Chappuis

Citation:

Envoyé par Linu6

je me demande si on a le drot de faire:

Code:

char text[80]=NULL

:roll:

Cela ne fait aucun sens, NULL est uniquement destiné à être utilisé dans un contexte de pointeur. Donc non, ce n'est pas correct!

Thierry
26/08/2007, 22h14
Thierry Chappuis

Citation:

Envoyé par gl

EOF permet d'indiquer que l'a fin du fichier est atteinte. Ce qui est indispensable si l'entree standard est un fichier et non la console (dans la plupart des shell, le caractere < permet une telle redirection).
Il est egalement possible depuis une console d'indiquer une fin de fichier (generalement avec les touches Ctrl + D si je ne me trompe pas)

Tu ne te trompes pas! C'est Ctrl + Z sous Windows et Ctrl + D sous unixoïde.

Thierry
26/08/2007, 22h17
Thierry Chappuis

Citation:

Envoyé par gl

Personnellement, s'il s'agit d'une chaine de caractere, j'ai une preference pour char text[80] = ""; qui revient strictement au meme et correspond mieux a une vision chaine de caracteres.

C'est vrai que c'est plus clair, je vais changer mon style.

Thierry
26/08/2007, 22h42
orfix
Salut,
je suis novice en C aussi en programmation , et je me suis poser quelques questions sur cette ligne de code proposer par ' Thierry Chappuis ' :
Code:

1 2 for (i = 0; i < sizeof text - 1 && (c = getchar()) != '\n' && c != EOF; i++)
-> est-ce que le -1 a été inclus pour ne pas remplir la dernière case de la chaine ,celle ou il faut mettre un ' \0 ' si tel est le cas ou est ce que l'on introduit le '\0' dans ce code , j'aurais penser faire ceci directe après la sortie de la boucle : text[i]='\0';

->aussi j'aurais jamais penser a mettre un sizeof mais plutôt : 80 puisque text[80], donc qu'elle est l'avantage ?

désolé si mes question sont un peu flou ou bebete ....!!:aie:
26/08/2007, 23h30
Gruik

Salut

Citation:

Envoyé par ssmario2

-> est-ce que le -1 a été inclus pour ne pas remplir la dernière case de la chaine ,celle ou il faut mettre un ' \0 ' si tel est le cas ou est ce que l'on introduit le '\0' dans ce code , j'aurais penser faire ceci directe après la sortie de la boucle : text[i]='\0';

C'est vrai que dans cet algo, on se sert de "cpt" lorsqu'on retraite les caractères de "text", donc on a pas besoin de laisser la place pour le '\0'.. mais je pense que Thierry prefere systematiquement mettre des chaines valides dans ses tableaux de caractères car ça serait plus évolutif si dans ce meme algo on avait besoin d'utiliser les fonctions du c standard sur les chaines (strlen).
Si on a pas mis text[i]='\0' à la sortie de la boucle c'est qu'on savait que "text" était remplit avec des '\0' dès son initialisation.

Citation:

->aussi j'aurais jamais penser a mettre un sizeof mais plutôt : 80 puisque text[80], donc qu'elle est l'avantage ?

Non, justement utiliser sizeof est plus intéressant, c'est plus abstrait, plus proche du sens originel, plus proche de ce qu'on voulait faire.
Une bonne pratique consiste à ne pas sortir les nombres de son chapeau car ils ont surement un sens particulier, donc en général on passe par des constantes, des tableaux d'infos, des resultats de fonctions/macros ou des opérateurs du langage C comme sizeof.
Si tu veux un avantage concret, si on augmente la taille du buffer, bein ya pas à changer le "80" partout.
26/08/2007, 23h41
Thierry Chappuis
Citation:
Envoyé par ssmario2

Salut,
je suis novice en C aussi en programmation , et je me suis poser quelques questions sur cette ligne de code proposer par ' Thierry Chappuis ' :

Code:

1 2 for (i = 0; i < sizeof text - 1 && (c = getchar()) != '\n' && c != EOF; i++)

-> est-ce que le -1 a été inclus pour ne pas remplir la dernière case de la chaine ,celle ou il faut mettre un ' \0 ' si tel est le cas ou est ce que l'on introduit le '\0' dans ce code , j'aurais penser faire ceci directe après la sortie de la boucle : text[i]='\0';
Ici, on sort de la boucle lorsque i vaut (sizeof text - 1), car la dernière case du tableau de caractères est réservée au caractère nul. Dans le code présenté, toutes les cases du tableau text ont été inialisées à 0 (ou '\0') lors de la déclaration du tableau:

Code:

char text[80] = {0};

ou, plus propre, comme l'a justement fait remarquer gl:

Code:

char text[80] = "";

Il n'y a dès lors pas besoin de placer un caractère nul en fin de chaîne de manière explicite à sortie de la boucle (mais rien n'interdit de le faire):
Code:

1 2 3 4 5 for (i = 0; i < sizeof text - 1 && (c = getchar()) != '\n' && c != EOF; i++) { /* ... */ } text[i] = 0;
Citation:

Envoyé par ssmario2

->aussi j'aurais jamais penser a mettre un sizeof mais plutôt : 80 puisque text[80], donc qu'elle est l'avantage ?

L'avantage se situe au niveau de la maintenance. En effet, si un jour tu décides de modifier la taille du tableau de caractères text, tu devras effectuer cette modification partout où tu as codé la valeur de cette taille en dûr dans ton code.

De manière générale, il est désirable de limiter au maximum l'usage de nombres magiques dans un programme. Ainsi on préfère itérer sur un tableau de la manière suivante:
Code:

1 2 3 4 5 6 7 8 9 #define TEXT_SIZE 80 char text[TEXT_SIZE] = "Bienvenue sur developpez.com"; int i; for (i = 0; i < TEXT_SIZE - 1; ++i) { /* ... */ }
ou
Code:

1 2 3 4 5 6 7 8 #define ARRAY_SIZE(a) ( sizeof (a)/sizeof *(a)) char text[80] = "Bienvenue sur developpez.com"; int i; for (i = 0; i < ARRAY_SIZE(text) - 1; ++i) { /* ... */; }
ou encore, comme sizeof(char) vaut 1 par définition:
Code:

1 2 3 4 5 6 7 char text[80] = "Bienvenue sur developpez.com"; int i; for (i = 0; i < sizeof text - 1; ++i) { /* ... */; }
Citation:

Envoyé par ssmario2

désolé si mes question sont un peu flou ou bebete ....!!:aie:

Il n'y a pas de problème, ni de questions bête.

Thierry
27/08/2007, 00h05
orfix

Salut,
....euhhhh...Je vous remercie pour vos réponses rapides même très rapide:king:, vos éclaircissements instructifs ,j'essayerais de prendre comme habitude de travailler avec des constantes au lieu de nombres magiques lol :mouarf: ,aussi j'ai appris bien plus de notions en 2minute sur votre forum qu'en 2 heures tout seul devant mon ordi, merci encore une fois.
27/08/2007, 00h31
Emmanuel Delahaye

Citation:

Envoyé par Linu6

..humm, pourtant pour vérifier si une entrée est de type char ou pas on peut recourir à la formulation suivante:

if(isalpha(text[i])
....

Si je ne m'abuse, dans ce cas le test foncionne non?

tu confonds tolower() et islower()...

Code:

1 2 3 4 5 6 7 8 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(*a)) char text[80] = "Bienvenue sur developpez.com"; int i; for (i = 0; i < ARRAY_SIZE(text) - 1; ++i) { /* ... */; }
Au fait je n'ai pas compris cette version, (même si les deux autres solutions me semblent très claires) :oops:

30/08/2007, 18h35
Emmanuel Delahaye

Citation:

Envoyé par Thierry Chappuis

Code:

#define ARRAY_SIZE(a) (sizeof(a)/sizeof(*a))

Je ne suis pas d'accord avec le terme 'size' qui désigne traditionnellement une taille d'objet en byte, c'est à dire la valeur retournée par l'opérateur sizeof.

Cette macro calcule la dimension ou le nombre d'éléments du tableau, ce qui est différent.

Je suggère donc, pour éviter toute confusion, de l'appeler NB_ELEM() ou DIM().

D'autre part, il y a une erreur dans les parenthèses :

Code:

#define NB_ELEM(a) (sizeof (a) / sizeof *(a))

Je rappelle qu'ici, comme dans toutes les macros, les parenthèses sont là pour assurer que l'expression passée en paramètre soit bien traitée en priorité.
30/08/2007, 18h41
Emmanuel Delahaye
Citation:
Envoyé par Linu6

Code:

1 2 3 4 5 6 7 8 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(*a)) char text[80] = "Bienvenue sur developpez.com"; int i; for (i = 0; i < ARRAY_SIZE(text) - 1; ++i) { /* ... */; }

Au fait je n'ai pas compris cette version, (même si les deux autres solutions me semblent très claires) :oops:
Tu ne comprends pas la macro ? Elle sert à calculer la dimension du tableau (son nombre d'éléments) en fonction de sa définition. En effet, un tableau est une suite contigüe d'éléments identiques. Sa taille est donc la taille d'un élément multipliée le nombre d'éléments :

Code:

size = size_of_elem x nb_elem

réciproquement, le nombre d'éléments (la dimension) est le rapport entre la taille totale et la taille d'un élément :

Code:

nb_elem = size / size_of_elem

(algèbre basique...)

ce qui se traduit en C en

Code:

nb_elem = sizeof tab / sizeof tab[0]

ou encore

Code:

nb_elem = sizeof tab / sizeof *tab

La macro ne fait que généraliser ce mécanisme...
30/08/2007, 22h27
Thierry Chappuis

Citation:

Envoyé par Emmanuel Delahaye

Je ne suis pas d'accord avec le terme 'size' qui désigne traditionnellement une taille d'objet en byte, c'est à dire la valeur retournée par l'opérateur sizeof.

Cette macro calcule la dimension ou le nombre d'éléments du tableau, ce qui est différent.

Je suggère donc, pour éviter toute confusion, de l'appeler NB_ELEM() ou DIM().

D'autre part, il y a une erreur dans les parenthèses :

Code:

#define NB_ELEM(a) (sizeof (a) / sizeof *(a))

Je rappelle qu'ici, comme dans toutes les macros, les parenthèses sont là pour assurer que l'expression passée en paramètre soit bien traitée en priorité.

Merci pour tes corrections, Emmanuel. J'ai été un peu vite dans la construction de mon exemple et j'ai oublié des parenthèses. C'est désormais corrigé! En ce qui concerne le nom de la macro, NB_ELEM() est plus judicieux, je suis d'accord...

Salutations

Thierry
30/08/2007, 23h00
Linu6

..et encore une question idiote.

Ceci..

Code:

nb_elem = sizeof tab / sizeof *tab

on ne pouvait pas la remplacer par

Code:

nb_elem = sizeof tab / sizeof tab

car tab est déjà un pointeur sur son premier éléments..? (d'après mes souvenirs..:aie:)
30/08/2007, 23h17
Emmanuel Delahaye

Citation:

Envoyé par Linu6

..et encore une question idiote.

Ceci..

Code:

nb_elem = sizeof tab / sizeof *tab

on ne pouvait pas la remplacer par

Code:

nb_elem = sizeof tab / sizeof tab

car tab est déjà un pointeur sur son premier éléments..? (d'après mes souvenirs..:aie:)

Je ne suis pas très fort en math, mais à mon avis, truc / truc, ça fait 1 quoi qu'il arrive. Il doit donc y avoir un défaut dans ton raisonnement...

On t'a filé du code qui fonctionne... Tout a été expliqué ici :

http://www.developpez.net/forums/sho...3&postcount=25

je ne sais pas quoi faire de plus...
30/08/2007, 23h26
Linu6

euh... il se fait tard, mais demain ça ira mieux, :cfou:
31/08/2007, 08h10
Thierry Chappuis

Citation:

Envoyé par Linu6

..et encore une question idiote.

Ceci..

Code:

nb_elem = sizeof tab / sizeof *tab

on ne pouvait pas la remplacer par

Code:

nb_elem = sizeof tab / sizeof tab

car tab est déjà un pointeur sur son premier éléments..? (d'après mes souvenirs..:aie:)

Un tableau n'est pas un pointeur, c'est un tableau! Lorsque son identificateur est utilisé au sein une expression, il y a conversion implicite en un pointeur sur le premier élément du tableau. Cette conversion n'a pas lieu lorsque le tableau en question est utilisé avec l'opérateur sizeof. C'est pour cette raison que sizeof tableau permet de déterminer la taille du tableau et non la taille occupée en mémoire par un pointeur.

Thierry
31/08/2007, 10h16
Jean-Marc.Bourguet

Il faut convertir les char en unsigned char avant de les passer a tolower, islower etc.
31/08/2007, 13h34
Thierry Chappuis

Citation:

Envoyé par Jean-Marc.Bourguet

Il faut convertir les char en unsigned char avant de les passer a tolower, islower etc.

A cause de la conversion en int? Merci pour le conseil! Je n'ai jamais fait cette convertion, mais je le ferai à l'avenir...

Thierry