Discussion :

[mouiteu]

Bonjour à tous!
Pour un TP je dois utiliser une procédure permettant de mettre en majuscule un nom. Cependant nous n'avons pas étudié les pointeur et les allocutions dynamique. Voici la fonction qui pose problème

déclaration:

Code :

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

void majuscule(string nom);

définition:

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
18
 
/////////////////////////////////////////////////////////////////////////////////////
//Procédure qui transforme une chaine en la même chaine entièrement en Majuscule
//		nom : nom que l'on veut transformer
//Précondition, Postcondition : aucune
/////////////////////////////////////////////////////////////////////////////////////
void majuscule(string nom)
{
	int i;//compteur
 
	for(i=0;i<=((signed)(nom.length())-1);i++)
	{
		if(nom.at(i)>='a' && nom.at(i)<='z')
		{
			nom.at(i)=nom.at(i)-'a'+'A';
		}
	}
}

et enfin l'appel dans mon code:

Code :

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

1
2
3
4
5
 
for(i=0;i<=n-1;i++)
{
	majuscule(noms[i]);
}

où noms[TAILLETAB] est u tableau de type string.

Je sais qu'on ne peut pas passer un tableau un paramètre et donc que le & est n'est donc pas à mettre(mais j'ai quand même essayé ce qui m'a valu une erreur de LINKER).

La compilation se déroule bien mais cependant la procédure ne fait rien, elle ne passe pas les noms en majuscule!!! Je pense donc que cela est du à sa définition, et que elle convertit en majuscule chaque nom, mais que ce changement est annulé en dehors de la procédure, comme si on avait une fonction.

Donc si quelqu'un pouvait m'expliquer la démarche à suivre pour faire fonctionner cette procédure ça m'arrangerait bien (sans pointeur de préférence). Merci!

[koala01]

Salut, et bienvenue sur le forum.

J'aurais aimé savoir si ton prof te demande d'utiliser la classe prévue par le C++ pour représenter les chaines de caractères (j'en serais surpris, mais bon, il y a quand même quelques "bons" profs ) ou s'il te demande d'utiliser une de ces horribles chaines "C style" (à savoir un tableau de caractères terminés par un '\0')...

en effet, le prototype de la fonction tel que tu le présente laisse planer un furieux doute (string est peut être une structure ou une classe créée par toi même ), et la solution risque de changer énormément en fonction de tes réponses à ces quelques questions

Au passage, avez vous déjà vu ce qu'est "une référence"

[mouiteu]

Nous n'avons pas encore vue les références, ni vraiment comment fonctionnent les chaîne de caractères. La seule chose que je sais c'est qu'une chaîne de caractère peut s'assimiler à un tableau (là j'imagine que c'est décrire la chose vraiment comme un brute mais je n'en sais pas plus!) et utiliser .length() et .at().

Sinon quand à sa nature je me contente d'inclure <string>. A noter qu'à part ce cas particulier, les autres procédures utilisant mon tableau de type chaîne de caractère fonctionne (saisie, test de palyndrome, recherche, affichage... d'ailleurs la procédure majuscule me sert à éviter les problèmes de casse pour le palyndrome et la recherche!)

Voilà, j'espère que ça t'éclairera sur mon problème! Merci!

[Mat007]

Salut,

Peut-être que ton prof' s'attend à quelque chose comme :

Code :

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

std::string majuscule(std::string nom);

Qui s'utiliserait donc du coup en faisant :

Code :

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

1
2
3
4
for(int i=0; i<=n-1; ++i)
{
	noms[i] = majuscule(noms[i]);
}

?

MAT.

[Davidbrcz]

Nous n'avons pas encore vue les références, ni vraiment comment fonctionnent les chaîne de caractères. La seule chose que je sais c'est qu'une chaîne de caractère peut s'assimiler à un tableau (là j'imagine que c'est décrire la chose vraiment comme un brute mais je n'en sais pas plus!) et utiliser .length() et .at().

Sinon quand à sa nature je me contente d'inclure <string>. A noter qu'à part ce cas particulier, les autres procédures utilisant mon tableau de type chaîne de caractère fonctionne (saisie, test de palyndrome, recherche, affichage... d'ailleurs la procédure majuscule me sert à éviter les problèmes de casse pour le palyndrome et la recherche!)

Voilà, j'espère que ça t'éclairera sur mon problème! Merci!

[HS]
Tu peux louer ton prof ! il est très très bon (présenter la STL dès le début, c'est génial) .
[HS]

L'inconvénient de la méthode majuscule ici présente, c'est qu'elle est hard-codée. Je conseile plutôt std::toupper, déclarée dans <cctype>, qui est faite pour ca.

[koala01]

[HS]
Tu peux louer ton prof ! il est très très bon (présenter la STL dès le début, c'est génial) .
[HS]

L'inconvénient de la méthode majuscule ici présente, c'est qu'elle est hard-codée. Je conseile plutôt std::toupper, déclarée dans <cctype>, qui est faite pour ca.

C'est vrai que ca se présente mieux que s'il avait parlé des chaines C style au départ

Nous n'avons pas encore vue les références, ni vraiment comment fonctionnent les chaîne de caractères. La seule chose que je sais c'est qu'une chaîne de caractère peut s'assimiler à un tableau (là j'imagine que c'est décrire la chose vraiment comme un brute mais je n'en sais pas plus!)

Tu sais donc que tu peux récupérer le caractère se trouvant à une position donnée de la chaine en écrivant quelque chose proche de
char c=str[i];

... et utiliser .length() et .at().

Sinon quand à sa nature je me contente d'inclure <string>.

Ca c'est bien, cela nous indique, comme l'a relevé Davidbrcz, que tu travaille avec la chaine de caractères fournie par le standard

C'est parce que, justement, il existe des méthodes que l'on peut avoir la certitude qu'il s'agit au minimum d'une classe (et le fichier est fourni par le sandard )

Je trouve juste surprenant qu'il ai parlé de leght et non de size... mais bon...

A noter qu'à part ce cas particulier, les autres procédures utilisant mon tableau de type chaîne de caractère fonctionne (saisie, test de palyndrome, recherche, affichage... d'ailleurs la procédure majuscule me sert à éviter les problèmes de casse pour le palyndrome et la recherche!)

Voilà, j'espère que ça t'éclairera sur mon problème! Merci!

Salut,

Peut-être que ton prof' s'attend à quelque chose comme :

Code :

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

std::string majuscule(std::string nom);

Qui s'utiliserait donc du coup en faisant :

Code :

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

1
2
3
4
for(int i=0; i<=n-1; ++i)
{
	noms[i] = majuscule(noms[i]);
}

?

MAT.

Pour le coup, ce serait plutôt

Code :

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

1
2
3
4
5
6
std::string majuscule(std::string str)
{
    for(size_t i = 0;i<str.length;++i)
        str[i]=std::toupper(str[i]);
    return str;
}

et appelée sous la forme de

Code :

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

1
2
3
4
5
6
7
int main()
{
    std::string s;/* la chaine à convertir */
    s = majuscule(s);
    /*...*/
    return 0;
}

mouiteu>> Si le prof est aussi bon que ce que laisse prévoir tes messages, il est fort vraisemblable qu'il introduise la notion de référence la prochaine fois, car le fait de passer une chaine en paramètre (sans la passer sous la forme d'une référence) implique la création d'une chaine temporaire, qui est la copie de la chaine originale, et qui est détruite en fin de fonction, et, que tout cela, ca demande des ressources

[mouiteu]

Merci à tous pour vos réponse!

J'ai finalement opté pour une fonction comme celle décrit par Mat007. Cela c'est révélé plus facile que prévu.
J'ai donc repris le code de ma procédure et je l'ai transformé en fonction renvoyant une chaîne de caractère. Je n'ai pas mis les std::string mais juste string( je crois qu'inclure <iostream> et marquer using namespace std; revient au même non?).

Les autres réponses étaient aussi intéressantes mais le sujet précisait bien d'utiliser des algorithmes faits en TD (d'où l'utilisation du -'a'+'A' pour le passage en majuscule, et le fait d'utiliser length par rapport au mot-clef longueur en Algo)

Sinon quand à mon prof, c'est un intervenant extérieur(il bosse donc en tant que programmeur en dehors de nos encadrement de TP) ce qui explique donc sa pédagogie(il nous inculque donc des principes et normes présent dans le "monde du travail", mais du coup on passe plus de temps à coder que d'autres groupes avec des profs plus classique ).

En tout cas merci pour votre aide et à bientôt (a mon avis )!

[nikko34]

si ton prof ne t'apprend pas les références et les const, tape lui dessus!

[koala01]

Merci à tous pour vos réponse!

J'ai finalement opté pour une fonction comme celle décrit par Mat007. Cela c'est révélé plus facile que prévu.
J'ai donc repris le code de ma procédure et je l'ai transformé en fonction renvoyant une chaîne de caractère. Je n'ai pas mis les std::string mais juste string( je crois qu'inclure <iostream> et marquer using namespace std; revient au même non?).

Déjà, iostream est le fichier qui inclu... les entrées/sorties standard (cin, cou, cerr et clog)...

Tu n'a donc pas besoin de l'inclure si tu ne fait qu'utiliser une chaine de caractères, et que tu n'a pas besoin de l'afficher

Evidemment, si tu as un fichier dans lequel tu utilise des chaines de caractères que tu dois afficher... il faut effectivement inclure les deux fichiers pour pouvoir profiter des chaines de caractères et des entrées / sorties standards

Mais, ce sur quoi je veux surtout attirer ton attention, c'est le fait qu'il n'est pas *forcément* nécessaire d'inclure <iostream> pour utiliser la directive using namespace std...

Pour que tu comprenne (cela devient fort HS, mais cela te permettra sans doute de prendre un peu d'avance sur les cours ), le langage est défini dans une norme.

Cette norme fournit énormément de fonctions, et de classes que l'on qualifie de... standards (logique ) qui couvrent un nombre impressionnant de secteurs, allant des entrées sorties aux conteneurs, en passant par les chaines de caractères et certains algorithmes.

Pour éviter les risques de conflits entre différentes classes qui auraient un nom identique mais qui auraient des objectifs différents, le langage permet d'utiliser ce que l'on appelle en français des espaces de noms ("namespace" en anglais).

Nous pourrions dire que cela agit comme une boite dont on pourrait voir de l'intérieur vers l'extérieur, mais qu'il faudrait ouvrir pour voir, de l'extérieur, ce qui se trouve à l'intérieur.

Evidemment tout ce qui se trouve à l'intérieur de la boite est capable de voir... ce qui se trouve à l'intérieur

Ajoute à cela que cette boite peut fonctionner sur le principe des "poupées russes" (une boite peut en contenir une ou plusieurs autre(s)), et tu auras un apperçu "correct" de ce que peuvent être les espaces de noms.

La norme donc a décidé de mettre tout ce qu'elle propose dans l'espace de nom std (pour... standard ), et c'est la raison pour laquelle tu remarquera souvent que les gens présentent des codes où on lit des

• std::string au lieu de string
• std::cin au lieu de cin
• std::cout au lieu de cout
• std::endl au lieu de endl
• std::vector<Type> au lieu de vector<Type>
• et j'en passe

Tu l'aura remarqué, il n'est malgré tout pas des plus aisé de se "trimbaler" sans cesse ce std:: qui précède tout ce qui se trouve dans l'espace de noms

C'est la raison pour laquelle le langage permet aussi "d'effacer" (temporairement) la démarcation qui existe entre les différents espaces de noms et l'espace de noms global (celui dans lequel tu te trouve quand tu n'indique rien).

Pour ce faire, il s'agit d'utiliser la directive using namespace (espace de nom à utiliser).

Tu pourrais croire que tout va très bien dans le meilleur des mondes si tu décidais d'utiliser de manière systématique cette directive, mais, à bien y réfléchir... le système d'inclusion vient tout foutre en l'air

En effet, si tu écris un fichier qui prend simplement la forme de

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
18
19
20
21
#include <string>
#include <iostream>
using namespace std;
class MaClass
{
    /*...*/
    std::string str;
};
void foo()
{
    /*...*/
}
void bar()
{
    /*...*/
}
int main()
{
    /*...*/
    return 0;
}

tu n'aura aucun problème majeur: la directive using sera limitée à ce fichier.

Les choses commenceront à se compliquer très sérieusement si tu commence à travailler de manière "modulaire", comprend, en créant plusieurs unités de compilations séparées, chacune étant constituée d'un fichier d'en-tête et d'un fichier d'implémentation.

Cette directive ne peut absolument pas se trouver dans un fichier d'en-tête, car cela pourrait provoquer des conflits majeurs

Imagines simplement que tu crées une classe personnalisée qui utilise la classe ... std::string:
Tu commencerais "logiquement" par créer le fichier d'en-tête sous la forme de

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
/*les gardes anti inclusion multiple */
#ifndef MYCLASS_HPP
#define MYCLASS_HPP
#include <string> /* tu a besoin de std::string */
/* c'est fatiguant d'écrire chaque fois std:: :-P mettons la directive
 * using namespace
 */
using namespace std;
class MyClass
{
    /*...*/
    string str;
};
/* la fin du garde contre l'inclusion multiple */
#endif // MYCLASS_HPP

Faut avouer que ça a l'air génial, comme cela, non

Sauf que, un peu plus loin, tu crée une autre classe qui s'appelle... string

Cette classe particulière n'a évidemment rien à voir avec... std::string, et tu crées donc un fichier proche de

Code :

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

1
2
3
4
5
6
7
#ifndef STRING_HPP
#define STRING_HPP
class string
{
    /*...*/
};
#endif // STRING_HPP

Pour l'instant, tout semble encore marcher "comme sur des roulettes" ... Malheureusement, ca ne va plus durer...

Car, un peu plus loin, tu va te trouver en situation d'avoir besoin de la classe MyClass et... de ta classe string...
Tu va donc commencer ton fichier d'implémentation sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
#inlcude "MyClass.hpp" /* inclusion du fichier d'en-tête de MyClass*/
#include "string.hpp" /* inclusion du fichier d'en-tete de ta classe string */
/*une fonction quelconque */
void foo()
{
    string str;/* nous sommes face à un conflit: s'agit-il de std::string ou de
               * string "perso" ???
               */
}

Bref, si j'ai écris ce roman, c'est pour attirer ton attention sur un fait bien particulier:
L'utilisation de la directive using namespace est - il faut l'avouer - très intéressante dans certaines situations, mais peut s'avérer réellement catastrophiques si tu la place "n'importe où"...

L'exemple que j'ai pris est encore assez simple, mais, quand on sait que la norme assure que les compilateur peuvent inclure "en cascade" jusqu'à un minimum de 256 fichier (donc un fichier qui en inclut un autre, qui en inclut lui même un troisième... qui en inclut un 256eme), on se dit qu'il devient rapidement beaucoup plus difficile de retrouver cette simple ligne

[mouiteu]

Okay! Merci pour l'explication sur namespace, c'était un des points qui n'avait pas été expliqué en cours.

Sinon en fait pour la référence, je croiscomprendre que c'était ce qu'on appelle "passage par paramètre" (c'est le const qui m'a mis la puce à l'oreille) : c'est le fait de ne pas agir directement sur une variable mais sur sa copie, comme dans une fonction ou un paramètre en lecture seule dans une procédure. Mais je croyais que ça ne marchait pas sur les tableaux?

Mais bon il semblerait qu'on va bientôt attaquer les pointeurs et les allocutions dynamique et que ça permettra de résoudre ce genre de problème!

[HanLee]

si ton prof ne t'apprend pas les références et les const, tape lui dessus!

Il n'est peut-être pas dans une école d'informatique, arrêtez de démarrer au quart de tour...

[koala01]

En fait, c'est justement l'inverse...

Quand tu travaille sans référence, tu va travailler sur une copie de la variable que tu passe en paramètre: sur une variable qui est créée spécialement pour la fonction appelée.

Cela implique que toutes les modifications que tu va effectuer dans la fonction appelées seront perdues dans la fonction appelante.

Il faut savoir que, dans certains cas, le fait de devoir copier l'intégralité du contenu d'une variable va prendre un temps "extrèmement long" (même si l'on s'entend sur la signification du "extèrement" ici ), et que, de plus, lorsque l'on quitte la fonction appelée, il y a aussi la destruction de la variable temoraire, qui prend tout autant de temps.

Une référence (là aussi, je prend un peu d'avance sur le cours) est ce que l'on appelle un alias de la variable référencée.

Cela signifie que, quand tu passe un paramètre par référence, tu ne travaille plus sur "une copie" de la variable, mais bel et bien... sur la variable elle-même.

Cela signifie par contre que tu va "économiser" tout ce qui a trait à la copie lors de la création et à la destruction de la variable.

C'est la raison pour laquelle on préfère généralement passer tous les objets qui ne sont pas des types primitifs (int, char, et autres)... sous la forme de références.

Mais, effectivement, si l'on ne souhaite pas (et cela peut arriver dans bien des situations) que la fonction appelée puisse aller modifier la variable dans la fonction appelante, il faudra signaler que c'est une référence... constante

A vrai dire, si tu avais vu les références, le code aurait encore pu être plus simple, sous une forme proche de

Code :

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

1
2
3
4
5
void majuscule(std::string& str)
{
    for(size_t i = 0;i<str.length;++i)
        str[i]=std::toupper(str[i]);
}

mais avec "l'effet de bord" que... lorsqu'elle est utilisée dans un code proche de

Code :

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

1
2
3
4
5
6
7
int main()
{
    std::string s;/* la chaine à convertir */
    majuscule(s);
    /*...*/
    return 0;
}

la variable s ne contiendrait plus que... des majuscules (avec impossibilité de récupérer la valeur initiale)

[mouiteu]

D'accord! Bon ben j'espère qu'on va bientôt attaquer ça en cours ( je suis en 1ère année d'IUT info)! Merci pour toutes ces explications! A plus!