Discussion :

[idrysa]

Bonjour,
je suis un debutant en C++ et j'aimerais avoir votre aide sur ce tp que je dois rendre aujourdhui!



1 Partie I
1.1 Exercice 1
Développer une classe String avec deux attributs privés : un pointeur sur un tableau de caractères et
un entier représentant la taille de la chaîne de caractères.
Il faut offrir deux constructeurs :
– le constructeur sans paramètre : la chaîne de caractères est alors vide (pointeur nul et taille égale
à 0) ;
– un constructeur avec un paramètre de type tableau de caractères dont la dernière case contient 0.
Le tableau défini dans la classe String ne doit contenir que les caractères de la chaîne. Le caractère
de fin de chaîne ne doit pas être utilisé.
1.2 Exercice 2
Ecrire le destructeur. Ce dernier doit libérer la mémoire allouée dans le constructeur.
1.3 Exercice 3
Développer des méthodes publiques d’accès et d’affichage de String :
– une méthode print qui affiche dans la console la chaîne de caractères ;
– une méthode qui retourne le nombre de caractères de la chaîne ;
– une méthode qui retourne le ième caractère de la chaîne (si i est supérieur à la taille de la chaîne
alors la méthode retourne un espace).
1
1.4 Exercice 4
Développer une méthode de concaténation de deux chaînes de caractères. Cette méthode aura l’entête
suivante : String concat(String& s) ; L’objet de type String retourné par la méthode est la chaîne résultante
de la concaténation.
1.5 Exercice 5
Ecrire un exemple qui présente :
1. la déclaration d’une variable s1 de type String à l’aide du constructeur par défaut ;
2. la déclaration d’une variable s2 de type pointeur sur une String à l’aide du constructeur à un
paramètre (la valeur “bonjour” sera passée en paramètre) ;
3. la déclaration d’une variable s3 de type String à l’aide du constructeur prenant en paramètre l’objet
déclaré en (2) ;
4. la déclaration d’une variable s4 de type String initialisée par la chaîne constante “à tous” ;
5. l’affectation de la variable déclarée en (1) par la variable déclarée en (3) ;
6. la déclaration d’une variable s5 de type référence sur un objet de type String ; cette variable
référencera la variable déclarée en (4) ;
7. la déclaration d’une variable s6 de type String initialisée par le résultat de la concaténation de la
chaîne déclarée en (2) et en (5) ;
Commentez votre code afin d’expliquer ce qu’il se passe lors de chacune des instructions. Pour faciliter
la compréhension des mécanismes, placez un affichage dans les différents constructeurs et dans le
destructeur et des affichages du contenu des différentes variables créées.
Ecrire les instructions nécessaires à la bonne terminaison de votre programme (par exemple, désallocation
mémoire).
Que se passe-t-il ? Commentez votre code avec la réponse à cette question.
1.6 Exercice 6
Ecrire le constructeur par recopie et la surcharge de l’opérateur =.
Quelles sont les conséquences ? Commentez votre code en indiquant les changements de comportements
des instructions de la question 5.
1.7 Exercice 7
Que se passe-t-il si la méthode qui retourne le ième caractère retourne une référence sur un char ?
Que peut-on faire avec cette nouvelle méthode ? Commentez un exemple pertinent.

[koala01]

Salut,

Je ne sais pas d'où tu tires cet exercice, mais il sent bon la préhistoire et le cours / tutoriel dont il est tiré devrait être jeté au buché et n'a pas vraiment de sens, car il ne t'apprend absolument rien (en C++, les chaines de caractères, c'est std::string, les tableaux, c'est std::vector, et un paramètre de type char * param ne représente pas forcément un tableau de caractères )

Pour le reste, si tu as suivi le cours, tu dois avoir au moins une vague idée de ce qu'est un pointeur, et de comment faire une allocation dynamique de la mémoire (ainsi que de la manière de libérer cette mémoire quand on n'en a plus besoin), ainsi que de la manière dont on déclare et dont on définit un constructeur, qu'il prenne ou non des paramètres, et un destructeur.

Comme tu n'apprendras pas grand chose si nous te donnons directement la solution, fait "au mieux de tes capacités" et montre nous le code; au besoin, en t'arrêtant à chaque étape indiquée dans l'exercice (mais si possible, uniquement lorsque tu rencontre un problème ). De cette manière, nous pourrons t'orienter vers la solution

[idrysa]

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
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
int main()
{
    String s1;
    String *s2;
    s2=new String("Bonjour");
    String s3(*s2);
    String s4("a tous");
    String &s5=s4;
   // s2->print();
    s4.print();
    cout<<"La valeur de la chaine est :"<<s2->ieme_caractere(S)<<"\0";
    s5.print();
    s3=s1;
 
    s2->concat(*s2).print();
    s1.print();
return  0;
}
.......................................................................................
.cpp
#include "String.h"
#include <iostream>
String::String()
{
    n=0;
    this->ch=NULL;
}
 
String::String(char *S)
{
    this->ch = new char[n+1];
    this->ch =S;
}
String::~String()
{
    if (this->ch!=NULL)
    delete{}this->p;
}
void String::print()
{
    cout<<"La chaine de caractere est :"<<this->p<<endl;
}
int String::nbre_de_caractere()
{
    for(int i=0;i<=N;i++)
        if(ch[i]!='\0')
        return i;
}
 
...................................................................................
.h
 
 
#ifndef STRING_H
#define STRING_H
 
class String
{
    public:
        String(); //constructeur sqns parametre
       String(/*const*/ char *);//constructeur avec un arqument de type tableau de caractere
        ~String();//le destructeur
        String(const String&);//constructeur de copie
       // char *fcpy(const char *tab);// la surcharge de l'operateur
        //methode d'acces
 
       // char *get_p();
       // void set_p(char* c);
 
        //methode d'affichage
        void print();
        int nbre_de_caractere(const char *tab);
        char ieme_caractere(int i);
        //methode de concatenation
        String concat(String& s);
    private:
        char* ch;
        int n;
 
};
 
#endif // STRING_H

[koala01]

pourrais tu déjà éditer ton message en entourant ton code de la balise [ CODE ] [ /CODE ] (sans les espace, cela correspond au bouton # qui se trouve au dessus à droite de la zone d'édition), de préférence en séparant clairement les différents fichiers ?

Sinon, pour le code:
1- tu n'as absolument aucune raison de créer une instance de ta classe String en ayant recours à l'allocation dynamique de la mémoire.
Si tu veux utiliser le constructeur de copie de ta classe, un code proche de

Code :

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

1
2
3
4
5
6
7
int main(){
    String str("salut ");
    String str2(str);
   /* et pour l'opérateur d'affectation, un code proche de */
   String str3;
   str3 = str;
}

devrait faire parfaitement l'affaire (à condition, bien sur, que ta classe soit correctement définie

2- depuis 2011, on préfère utiliser nullptr au lieu de NULL

3- utilises de préférence les listes d'initialisation dans tes constructeurs

4- le constructeur prenant un char * en parametre est totalement faux:
a) n n'a pas été calculé, et, dans le meilleur des cas, il vaut 0... utilise la fonction strlen pour savoir combien de caratères sont contenu dans ton char *
b) le code this->ch =S; ne fait qu'affecter la valeur de l'adresse mémoire à laquelle se trouve S à ch, ce qui occasionne une fuite mémoire pour la valeur précédente de ch, et qui posera problème si S ne correspond pas à une adresse mémoire pour laquelle on a eu affaire à l'allocation dynamique (autrement dit, avec un code proche de String str("salut");Une fois que tu as alloué dynamiquement un espace suffisant pour contenir l'ensemble des caractères de S dans ch, tu dois effectuer une copie en profondeur de S, soit à l'aide de la fonction strcpy, soit à l'aide de la fonction memcpy

5- pour libérer la mémoire allouée par newou par new[], tu dois utiliser le delete équivalent (deletepour new, delete[] pour new[]) ne pas le faire occasionne un comportement indéfini

6- la norme garanti delete (ou delete[]) sur nullptr (ou sur NULL) n'aura aucun effet... tu n'as donc pas besoin de faire la vérification

7- il manque le constructeur de copie (!!! il faut faire une copie en profondeur !!! ) et l'opérateur d'affectation (!!! attention au risque de fuite de mémoire... le meilleur moyen passe sans doute par l'idiome "copy and swap" )

8- pourquoi calculer le nombre de caractères, alors que, a prior, tu le connait au travers de n

9- sois attentif au fait que C++ est sensible à la casse: mavar, MaVar et MAVAR sont trois variable totalement différente pour lui