Discussion :

[elgeek]

Bonjour,
voilà, je dois développer une classe ou le constructeur initialise une chaine de caractère. Jusque là aucun problème.

Le soucis, c'est que je dois convertir cette chaine taper en minuscule, en MAJUSCULE...et là je ne sais pas comment faire. Ma chaine de caractére est stocké dans un const char* machaine....

JE penses qu'il faut faire avec le code ascii (car en fait il faut enlever 32 au code ascci du caractère en question pour obtenir une majuscule) mais j'avoue ne pas trouver sur se coup là, pourriez vous me donner un coup de main svp ?

merci

[JolyLoic]

http://cpp.developpez.com/faq/cpp/in...TRINGS_tolower

[Steph_ng8]

C'est dans ce genre de situations qu'on apprécie l'en-tête « ctype.h » !
Il y a pas mal de fonctions C de manipulation de caractères.

Code :

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

1
2
3
4
#include <cctype>
 
int toupper(int c);
int tolower(int c);

Par contre, ces deux fonctions ne marchent qu'avec les 26 lettres « normales ».

Comme les autres fonctions de ctype.h, elles prennent en paramètre le code ASCII d'un caractère (typiquement, un unsigned char transtypé en int, ou EOF).
Elles retournent le code ASCII du caractère transformé en cas de succès, ou celui passé en paramètre en cas d'échec.

[elgeek]

merci pour vos reponses mais en fait je dois faire par une boucle.

Voici ce que j'ai fait

for (int c=0;c<size;c++)
{
if(chaine[c]>='A'&& chaine[c]<='Z')
chaine[c]=chaine[c]-32;
}


A savoir que chaine est un pointeur char* et size un strlen[chaine]

le tout passe bien à la compilation mais lors de l'execution ca plante..

[Steph_ng8]

Ce n'est pas étonnant.
Tu commences par vérifier que le caractère est déjà une majuscule avant d'essayer de le convertir.

Ce code devrait mieux fonctionner :

Code :

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

1
2
3
4
5
for (int c = 0; c < size; c++)
{
    if (chaine[c] >= 'a' && chaine[c] <= 'z')
        chaine[c] -= 32;
}

Mais comme dit précédemment, il y a des fonctions standard pour ça.

Code :

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

1
2
3
4
5
6
7
8
#include <cctype>
 
(...)
 
for (int c = 0; c < size; c++)
{
    chaine[c] = std::toupper(static_cast<unsigned char>( chaine[c] ));
}

Ou, encore mieux :

http://cpp.developpez.com/faq/cpp/in...TRINGS_tolower

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
#include <cctype>    // pour toupper
 
struct my_toupper
{ 
    char operator()(char c) const 
    {
        return std::toupper(static_cast<unsigned char>(c));
    } 
};
 
 
/***************************************/
 
#include <algorithm> // pour transform
 
 
std::transform(chaine, chaine + size, chaine, my_toupper());

[Steph_ng8]

Euh là je t'ai mis le code pour un char *.
Mais en C++, il vaut mieux utiliser les std::string.

[Saintux]

C'est normal si tu créé ton objet comme ça :

Code :

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

1
2
 
CChaine* truc = new CChaine("chaine");

"chaine" est alors une constante, d'où tu ne peut pas modifier les caractères qui la compose.

Une solution serait de changer ton constructeur pour faire une copie de la chaine dans un emplacement de mémoire modifiable:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
CChaine::CChaine(const char* texte)
{
    chaine = new char[strlen(texte)];
    strcpy(chaine, texte);
    m_size=strlen(chaine);
 
}
 
CChaine::~CChaine()
{
    delete[] chaine;
}

PS : L'erreur "windows a cessé de fonctionner" te dis qu'il y a eu une erreur de segmentation ( tentative d'accès à une partie de la mémoire que ton programme n'avais pas à modifier ).

[elgeek]

En fait, le main m'est imposé de la facon suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include "Chaine.h"
 
void main()
{
	CChaine obj="je fais un test";
	obj.Show();
	obj.Upper(); // l'erreur se passe à ce niveau
	obj.Show();
 
}

[Steph_ng8]

Ce code me paraît plus correct.
Il ne faut pas oublier le caractère nul en fin de chaîne !

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
#include <cstring>
 
(...)
 
CChaine::CChaine(const char* texte)
{
    m_size = strlen(texte);
    chaine = new char[m_size + 1];
    strcpy(chaine, texte);
}
 
CChaine::~CChaine()
{
    delete[] chaine;
}

Pour ce qui est de la conversion, je te conseille encore une fois d'utiliser toupper.

[Saintux]

En effet, c'est mieux, j'avais fais ça vite

@elgeek : remplace le constructeur et le destructeur de ta classe par ce que Steph_ng8 a mis, ça résoudra ton problème.

[Steph_ng8]

Ça reste une approche pas très C++, quand même…
C'est important de savoir manipuler des char*, mais utiliser le standard (donc std::string) c'est mieux.
À moins d'avoir des besoins très spécifiques et de savoir exactement ce qu'on fait…

Ici, ça a l'air d'être un exercice, et on t'a peut-être imposé d'utiliser les char*.
Mais à l'avenir, tourne-toi plutôt vers les std::string.
Non seulement ça facilite la manipulation des chaînes de caractères, mais en plus ça évite de gérer la mémoire.

[Astraya]

Un char * est constant, tu ne peux pas le modifier.
Pour une chaine de caractère non constant la bonne déclaration est char chaine[taille]!
Utilise les string, ils prennent en paramètre constructeur des char*.
Sinon au traitement fait une copie dans un char[m_size], libère l'ancien pointeur, fait le pointer sur le char[m_size].

[Steph_ng8]

Un char * est constant, tu ne peux pas le modifier.

Ah bon ?
Depuis quand ?

Pour une chaine de caractère non constant la bonne déclaration est char chaine[taille]!

Mouais, sauf qu'après on ne peut plus en modifier la taille…

Je crois que j'ai besoin d'un cours de rattrapage sur les pointeurs.
Soit T un type donné.

• T *
• pointeur simple
• la valeur du pointeur peut être modifiée
• les données pointées peuvent être modifiées

• const T * | T const *
• pointeur sur une constante
• la valeur du pointeur peut être modifiée
• les données pointées ne peuvent pas être modifiées

• T[] | T * const
• pointeur constant
• la valeur du pointeur ne peut pas être modifiée
• les données pointées peuvent être modifiées

• const T[] | const T * const | T const * const | (T const [] ?)
• pointeur constant sur une constante
• la valeur du pointeur ne peut pas être modifiée
• les données pointées ne peuvent pas être modifiées

Où me suis-je trompé ?

(http://c.developpez.com/faq/?page=po...OINTEURS_const)

[Astraya]

Essaye d'éditer un char* sans faire de copie ou allouer une espace mémoire supplémentaire

Code :

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

1
2
3
4
5
6
 
int main
{
char * chaine = "machaine";
//...
}

[MatRem]

Un bon compilateur devrait interdire cette syntaxe et t'obliger à écrire :

Code :

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

char const * chaine ="machaine";

[Steph_ng8]

Essaye d'éditer un char* sans faire de copie ou allouer une espace mémoire supplémentaire

Code :

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

1
2
3
4
5
6
 
int main
{
char * chaine = "machaine";
//...
}

Ah c'est sûr que si tu pars sur les chaînes constantes statiques…
D'ailleurs, leur type c'est plutôt const char*, non ?

Un bon compilateur devrait interdire cette syntaxe et t'obliger à écrire :

Code :

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

char const * chaine ="machaine";

Ah… je me disais, aussi…