Discussion :

[Aizen64]

Salut!

Il y a de nombreux points que je souhaiterai aborder, je suis pour ainsi dire, tout naze en C/C++ mais j'aimerai justement savoir l'utiliser pour essayer de créer des petits programmes légers, ce que .NET à bien du mal à faire et ce qui peut mener à la catastrophe en C/C++ quand on ne sait pas gérer dynamiquement la mémoire. Justement, je ne sais pas faire ça.

Le problème c'est que n'importe quel prog que je fais en objet ne compile jamais, erreurs de syntaxe entre autres je suppose alors justement je tiens a clarifier quelques trucs :

- A quoi sert "::" devant une méthode ?

- this en C/C++ a t-il la même signification qu'en C# auquel cas c'est un pointeur sur l'objet en cours d'utilisation.

- Pourquoi utiliser "->" au lieu d'un point ?

Quand on veut utiliser une méthode d'un objet c'est pas un point qu'il faut utiliser plutôt ? Comme : MonObjet.maMethode()

Quand je créé une classe, comment je suis censé m'y prendre, je vais expliquer, parce que ces histoires de fichiers cpp et .h m'embrouillent :

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
 
/* Fichier Cpp - je mets les #include avant la déclaration de la classe ? */
 
 
class Machin
{
private:
 
void Methode1()
{
     /* code méthode */
} /* Y doit y avoir un point virgule ici ou pas ? */
 
 
public:
 
void MaMethode()
{
// le code ici
}
};

Contenu du fichier .h :

Seulement les bibliothèques et les signatures des méthodes avec ";" à la fin de chaque méthode, le tout dans la déclaration de la classe ?

Y a pas de raisons que je m'en sorte pas, je suis pas mauvais en C#, pour ce qui est de l'EDI je sais pas lequel prendre, et pour ce qui est de me simplifier la tâche je compte bien installer Boost.

Y a uelqu'un d'assez patient pour m'expliquer tout ça ?

[Obsidian]

Il vaut mieux que tu lises un bon cours pour apprendre C++, comme le cours C++ de casteyde christian

Mais comme c'est écrit proprement, demandé gentillement et exposé de façon claire, je vais détailler :

- A quoi sert "::" devant une méthode ?

C'est l'opérateur de portée. Il permet en cas d'ambigüité de spécifier le namespace ou la classe auxquels ton entité appartient. Tu peux en mettre plusieurs pour remonter dans l'affiliation aussi loin que nécessaire.

- this en C/C++ a t-il la même signification qu'en C# auquel cas c'est un pointeur sur l'objet en cours d'utilisation.

Oui.

- Pourquoi utiliser "->" au lieu d'un point ?

Tu utilises cet opérateur lorsque tu as un pointeur sur une classe ou une structure. L'opérateur agit comme le "." mais déréférence automatiquement et en premier lieu le pointeur avant d'accéder au membre. Ça t'évite un (*ptr).membre.

Quand on veut utiliser une méthode d'un objet c'est pas un point qu'il faut utiliser plutôt ? Comme : MonObjet.maMethode()

Si.

Quand je créé une classe, comment je suis censé m'y prendre, je vais expliquer, parce que ces histoires de fichiers cpp et .h m'embrouillent :

Voir la discussion à ce sujet ici :
http://www.developpez.net/forums/d59...hiers-headers/

Pour les point-virgules, c'est pas compliqué. Soit tu écris une expression unique clôturée par un « ; », soit tu écris un bloc { }, qui contient de telles expressions.

Oui mais alors, pourquoi faut-il toujours mettre un point-virgule à la fin d'une déclaration de classe ? Parce que dans ce cas précis, l'expression n'est pas complète. Ça fonctionne comme pour struct : la définition de la classe est vue comme un nom de type, qui peut être suivi de noms de variables à instancier. Comme on n'en est pas encore là, on se contente de refermer sans préciser de variable.

[Aizen64]

Y a quelques trucs ou j'ai du mal, des trucs assez bètes :

quand je regarde le cours de C++ que tu m'as donné, il montre un destructeur comme ça :

Code :

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

1
2
3
4
5
 
    ~Destructeur(void)
    {
        return;
    }

Mais il fait quoi là ? Le destructeur s'appelle lui même et ne fait rien ?!!

Encore une question concernant les classes en C++, avec le cpp et .h, le .h doit il aussi contenir les déclarations des variables membres ? C'est ce que j'ai fait mais je tiens à être su, en plus est ce que dans les include je mets les .h ou non avec des "" ou <> ?

J'ai fait une classe toute conne élève, avec un nom, prénom et age, avec les assesseurs, ça donne ça sur le .h :

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
 
#ifndef ELEVE_H_INCLUDED
#define ELEVE_H_INCLUDED
 
#include <stdlib.h>
#include <iostream.h>
#include <string.h>
 
class Eleve
{
    private:
 
    char Nom[31];
    char Prenom[31];
    int Age;
 
    public:
 
    Eleve(*char nom, *char prenom, int age);
    char* getNom();
    char* getPrenom();
    int getAge();
 
 
};
 
#endif // ELEVE_H_INCLUDED

Et sur le cpp :

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
 
#include <stdlib.h>
#include <iostream.h>
#include <string.h>
 
class Eleve
{
    private:
 
    char Nom[31];
    char Prenom[31];
    int Age;
 
    public:
 
    Eleve(*char nom, *char prenom, int age)
    {
        Nom[31] = nom;
        Prenom[31] = prenom;
        Age = age;
    }
 
    char* getNom()
    {
        return this->Nom;
    }
 
    char* getPrenom()
    {
        return this->Prenom;
 
    }
 
    int getAge()
    {
        return Age;
    }
 
 
    ~Eleve(void)
    {
        return;
    }
 
};

Bon tout ça ne compile pas alors, déjà faut éviter de sauter au plafond si j'ai utilisé des pointeurs qui servent peut être à rien, compte tenu que ça devrait être une chaine de caractère constante saisie par l'utilisateur, j'ai utilisé un pointeur dans le constructeur.

Heu.. aussi concernant le renvoi des variables membres nom et prénom via les assesseurs, c'est un peu suspect ce que j'ai fait je devrais renvoyer le tableau (donc char[]), j'avoue que ne pas avoir de type "string" ne rend pas les choses si pratiques.

J'utilise CodeBlocks (dernière version) et le compilateur GNU GCC. Au fait comment je doit m'y prendre pour installer Boost ?

[Noxen]

Ce destructeur ne fait effectivement aucun traitement. Si tu ne déclares pas de destructeur, le compilateur génèrera un destructeur implicite. Les deux raisons essentielle de déclarer un destructeur sont : tu as gère des objets de façon dynamique dans ta classe, il te faudra désallouer la mémoire explicitement dans le destructeur ; ta classe est une classe de base, dont hériteront d'autres classe, et il te faut déclarer un destructeur en virtual, même s'il ne fait aucun traitement.

Tu fais #include "fichier.h" si le fichier est dans le même répertoire de fichier courant, et #include <fichier.h> (ou #include <fichier>, si c'est un fichier de la bibliothèque standard), si ton fichier est dans la liste des répertoires d'inclusion de ton IDE, ce qui est le cas par défaut des fichiers include de la bibliothèque standard, et des répertoire que tu auras explicitement spécifiés.

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
 
// Fichier Eleve.h
#ifndef ELEVE_H_INCLUDED
#define ELEVE_H_INCLUDED
 
//#include <stdlib.h> Bibliothèque standard du C, ici c'est du C++
// si tu en as quand même besoin, fait plutôt : #include <cstdlib>
#include <iostream> // L'usage de <iostream.h> est obsolète
#include <string> // L'usage de <string.h> est obsolète
 
class Eleve
{
    private:
 
    std::string Nom; // Il y a bien un type string dans la STL
    std::string Prenom; // std pour l'espace de nom standard
    int Age;
 
    public:
 
    Eleve(string nom, string prenom, int age);
    string getNom();
    string getPrenom();
    int getAge();
 
};
 
#endif // ELEVE_H_INCLUDED

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
 
// Fichier Eleve.cpp
#include "Eleve.h" // Pour que ce fichier de code connaisse la déclaration de la classe Eleve
 
Eleve::Eleve(string nom, string prenom, int age): // Constructeur
Nom(nom), Prenom(prenom), Age(age) // avec liste d'initialisation
{}
 
std::string Eleve::getNom()
{
    return this->Nom;
}
 
std::string Eleve::getPrenom()
{
    return this->Prenom;
}
 
int Eleve::getAge()
{
    return Age; // this est effectivement optionnel ici
}
 
//~Eleve(void) // N'a pas été déclaré dans la classe, provoquerait une erreur
//{ // Mais déclarer explicitement un destructeur n'est pas nécessaire ici
//    return;
//}

Mais un cours ou un tutoriel devrait arriver à t'expliquer tout ça. Bon courage

[Spout]

Effectivement tu peux utiliser des std::string à la place de tes chaîne de caractères. Ca t'évitera des problème de gestion de mémoire.

Concernant tes fichiers, tu déclares deux fois ta classe eleve:

Code :

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

1
2
3
4
class eleve
{
     ...
};

Tu ne dois avoir qu'un déclaration avec la classe, ses attributs, ses méthodes,... et une définition pour chaque méthode. Ainsi tu auras

Code eleve.h :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class aleve
{
private:
    char Nom[31];
    char Prenom[31];
    int Age;
 
public:
    Eleve(*char nom, *char prenom, int age);
    char* getNom();
    char* getPrenom();
    int getAge();
 
}

Code eleve.cpp :

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
Eleve::Eleve(char* nom, char* prenom, int age)
{
   // implémentation du constructeur
   ....
}
 
char* Eleve::getNom()
{
   // implémentation du getNom
   ....
   return /* un char* */;
}
 
char* Eleve::getPrenom()
{
   // implémentation du getPrenom
   ....
   return /* un char* */;
}
 
int Eleve::getAge()
{
   // implémentation du getAge
   ....
   return /* un int */;
}

[Alp]

Au passage, n'hésite surtout pas à utiliser la FAQ C++ qui répondra à pas mal de tes questions.

Pour std::string, il faut utiliser la ligne suivante :

Code :

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

#include <string>

Qui permet de connaitre la déclaration de la classe, et donc quelles fonctions membres elle possède, etc.

Pour le destructeur : non il ne s'appelle pas tout seul.
Voici comme ça se passe.

Code :

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

1
2
3
4
{
MaClasse objet(arguments du constructeur);
// ... on se sert de objet
} // ici le destructeur est appelé _automatiquement_

Si tu utilises l'allocation dynamique (pointeur + new , delete) :

Code :

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

1
2
3
4
{
MaClasse* objet = new MaClasse(arguments du constructeur);
// ... on se sert de objet
} // ici le destructeur n'est pas appelé tout seul car en utilisation l'allocation dynamique, on prend la responsabilité de gérer la destruction

ce à quoi on remédie par :

Code :

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

1
2
3
4
MaClasse* objet = new MaClasse(arguments du constructeur);
// ...
delete objet;
}

En C++, on dispose de manière non standard (pour le moment) de classes qui encapsulent des pointeurs et permettent de s'en servir comme des pointeurs, alors que ce sont pourtant des instances normales. Et elles sont du coup détruites toutes seules, sans s'en soucier.

Code :

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

1
2
3
4
5
{
PointeurIntelligent<MaClasse> objet(arguments du constructeur);
objet->methode();
// ...
} // le pointeur se détruit tout seul, étant géré par la classe PointeurIntelligent

(il n'existe pas de classe nommée "PointeurIntelligent", c'est pour l'exemple)

[Aizen64]

Alp j'ai pas compris un truc là, pourquoi utiliser un pointeur sur la classe de l'objet que l'on veut créer ? Ça devrait suffire nan ?

Classe objet = new Classe();

[Alp]

Car si tu appelles new, il faudra que tu fasse un delete sur l'objet ainsi crée.
Alors qu'avec PointeurIntelligent, tu n'as pas à t'en soucier.

[Obsidian]

Car si tu appelles new, il faudra que tu fasse un delete sur l'objet ainsi crée.
Alors qu'avec PointeurIntelligent, tu n'as pas à t'en soucier.

C'est une possibilité, mais je ne pense pas que ce soit un exemple à donner à un débutant C++ ... Enfin, ce n'est que mon avis.

[Obsidian]

Alp j'ai pas compris un truc là, pourquoi utiliser un pointeur sur la classe de l'objet que l'on veut créer ? Ça devrait suffire nan ?

Classe objet = new Classe();

Attention, tu retombes dans le travers Java ! De deux choses l'une, ou tu instancies directement l'objet (dans la pile), et il sera détruit dès la sortie du bloc :

Code :

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

Classe objet;

Ou tu crées un objet persistant dans le tas avec new. Dans ce cas, la commande te renverra son emplacement en mémoire et il te faut un pointeur pour la recevoir. Ensuite, tu devras toi-même libérer la mémoire au moment qui te plaît en faisant un delete de ton objet ... sur son emplacement en mémoire.

Code :

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

Classe * pointeur = new Classe;

Dans ton exemple, tu instancies d'une part un nouvel objet, puis tu essaies de lui affecter un pointeur. Ce n'est pas du même type, ça ne fonctionnera pas.

C'est dangereux parce que s'il venait à l'esprit d'un codeur de déréférencer le pointeur renvoyé par new (truc style Classe objet = * new Classe; ), l'affectation aurait bien lieu, mais les deux objets existeraient en mémoire et il n'y aurait plus moyen de libérer le second.

[Alp]

C'est une possibilité, mais je ne pense pas que ce soit un exemple à donner à un débutant C++ ... Enfin, ce n'est que mon avis.

C'était juste pour lui dire que le gros cliché "En C++ faut toujours manipuler des pointeurs et on peut pas ne pas se soucier de leur destruction" est faux