Langage c++

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Fonctions membres en C++

Une fonction est un ensemble d'instructions qui prennent des entrées, effectuent des calculs spécifiques et produisent une sortie.

L'idée est de regrouper certaines tâches effectuées de manière courante ou répétée et de créer une fonction permettant d'appeler la fonction au lieu d'écrire le même code encore et encore pour différentes entrées.

Une déclaration de fonction indique au compilateur le nom, le type de retour et les paramètres d'une fonction. Une définition de fonction fournit le corps réel de la fonction.

Syntaxe :
                                type_retour nom_fonction( liste de paramètres ) {
                                    // corps de la fonction
                                }
                            

Une définition de fonction C ++ consiste en un en-tête de fonction et un corps de fonction. Voici toutes les parties d'une fonction

  •   Type de retour - Une fonction peut renvoyer une valeur. type_retour est le type de données de la valeur renvoyée par la fonction. Certaines fonctions effectuent les opérations sans renvoyer de valeur. Dans ce cas, type_retour est le mot clé void.
  •   Nom de la fonction - C'est le nom actuel de la fonction. Le nom de la fonction et la liste des paramètres constituent ensemble, la signature de la fonction.
  •   Paramètres - Un paramètre est comme un espace réservé. Lorsqu'une fonction est appelée, vous transmettez une valeur au paramètre. Cette valeur est appelée paramètre ou argument réel. La liste de paramètres fait référence au type, à l'ordre et au nombre de paramètres d'une fonction. Les paramètres sont facultatifs. c'est-à-dire qu'une fonction peut ne contenir aucun paramètre.
  •   Corps de la fonction - Le corps de la fonction contient une collection d'instructions qui définissent ce que fait la fonction.
Déclaration d'une fonction :
                                int max(int, int);
                            

Les noms de paramètre ne sont pas importants dans la déclaration de fonction, mais leur type est obligatoire

Définition d'une fonction :
                                int max(int x, int y)
                                {
                                    if (x > y)
                                        return x;
                                    else
                                        return y;
                                }
                            
Appeler une fonction :

Pour appeler une fonction, il vous suffit de transmettre les paramètres requis ainsi que le nom de la fonction. Si la fonction renvoie une valeur, vous pouvez stocker la valeur renvoyée.

                                int main()
                                {
                                    int a = 4, b = 7;
                                    int c = max(a, b);
                                    cout << "max(a, b)" << c << endl;
                                    // ou simplement cout << "max(a, b)" << max(a, b) << endl;

                                    return 0;
                                }
                            

Passage des paramètres

Les paramètres passés à function sont appelés paramètres réels. Par exemple, dans le programme ci-dessus, les paramètres a et b (4 et 7) sont réels.

Les paramètres reçus par fonction sont appelés paramètres formels. Par exemple, dans le programme ci-dessus, x et y sont des paramètres formels.

Lors de l’appel d’une fonction, il existe trois manières de transmettre des arguments à une fonction.

  •   Passage par valeur
  •   Passage par adresse
  •   Passage par référence

Passage par valeur

Dans cette méthode de transmission des paramètres, les valeurs des paramètres réels sont copiées dans les paramètres formels de la fonction et les deux types de paramètres sont stockés dans des emplacements mémoire différents. Ainsi, toutes les modifications apportées aux fonctions ne sont pas reflétées dans les paramètres réels de l'appelant.

Par défaut, C ++ utilise le passage par valeur pour transmettre des arguments. En général, cela signifie que le code d'une fonction ne peut pas modifier les arguments utilisés pour appeler la fonction.

Exemple :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    void echanger(int x, int y);
                                    
                                    int main()
                                    {
                                        int a = 4, b = 7;
                                        echanger(a, b);
                                        cout << "a = " << a << "  -  b = " << b << endl;
                                        return 0;
                                    }
                                    
                                    void echanger(int x, int y)
                                    {
                                        int c = x;
                                        x = y;
                                        y = c;
                                    }
                            
a = 4 - b = 7

comme vous pouvez le voir dans l'exemple ci-dessus, les valeurs de et b ne changent pas après l'appel de la fonction echanger

Passage par adresse

le passage par adresse (ou pointeur) copie l'adresse d'un argument dans le paramètre formel. A l'intérieur de la fonction, l'adresse est utilisée pour accéder à l'argument réel utilisé dans l'appel. Cela signifie que les modifications apportées au paramètre affecte l'argument passé.

Pour transmettre la valeur par adresse, nous déclarons les paramètres comme des pointeurs et nous appelons la fonction en transmettant les adresses des arguments.

Exemple :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    void echanger(int *x, int *y);
                                    
                                    int main()
                                    {
                                        int a = 4, b = 7;
                                        echanger(&a, &b);
                                        cout << "a = " << a << "  -  b = " << b << endl;
                                        return 0;
                                    }
                                    
                                    void echanger(int *x, int *y)
                                    {
                                        int c = *x;
                                        *x = *y;
                                        *y = c;
                                    }
                            
a = 7 - b = 4

Veuillez lire le cours sur les pointeurs pour plus de détails.

Passage par référence

Le passage par référence copie la référence d'un argument dans le paramètre formel. Dans la fonction, la référence est utilisée pour accéder à l'argument utilisé dans l'appel. Cela signifie que les modifications apportées au paramètre affectent l'argument passé.

Pour transmettre la valeur par référence, la référence de l'argument est transmise aux fonctions comme toute autre valeur. En conséquence, vous devez donc déclarer les paramètres de la fonction comme des références, comme dans la fonction suivante echanger(), qui échange les valeurs des deux variables entières désignées par ses arguments.

Exemple :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    void echanger(int &x, int &y);
                                    
                                    int main()
                                    {
                                        int a = 4, b = 7;
                                        echanger(a, b);
                                        cout << "a = " << a << "  -  b = " << b << endl;
                                        return 0;
                                    }
                                    
                                    void echanger(int &x, int &y)
                                    {
                                        int c = x;
                                        x = y;
                                        y = c;
                                    }
                            
a = 7 - b = 4

Pssage par adresse VS Passage par référence

En C ++, nous pouvons transmettre des paramètres à une fonction, soit par adresse, soit par référence. Dans les deux cas, nous obtenons le même résultat. Les questions suivantes sont donc inévitables. quand l'un est-il préféré à l'autre ? Quelles sont les raisons pour lesquelles nous utilisons l'un sur l'autre ?

Les références sont généralement implémentées à l'aide de pointeurs. Une référence est le même objet, mais avec un nom différent et la référence doit faire référence à un objet. Comme les références ne peuvent pas être NULL, leur utilisation est plus sûre.

  •   Un pointeur peut être réaffecté, alors que la référence ne le peut pas et doit être attribué à l'initialisation uniquement.
  •   Le pointeur peut être affecté directement à NULL, alors que la référence ne le peut pas.
  •   Les pointeurs peuvent parcourir un tableau, nous pouvons utiliser ++ pour aller à l'élément suivant pointé par un pointeur.
  •   Un pointeur est une variable qui contient une adresse mémoire. Une référence a la même adresse mémoire que l'élément référencé.
  •   Un pointeur sur un objet de classe/structure utilise "->" pour accéder à ses membres alors qu’une référence utilise un "."
  •   Un pointeur doit être déréférencé avec * pour accéder à l'emplacement de la mémoire pointé, alors qu'une référence peut être utilisée directement.
  •   Les références sont généralement préférées aux pointeurs chaque fois que nous n’avons pas besoin de «replacer».

Dans l’ensemble, utilisez des références lorsque vous le pouvez et des pointeurs lorsque vous devez le faire.

Fonctions membres de la classe

Une fonction membre d'une classe est une fonction qui a sa définition ou son prototype dans la définition de classe comme toute autre variable. Il opère sur tout objet de la classe dont il est membre et a accès à tous les membres d'une classe pour cet objet.

Prenons la classe précédemment définie pour accéder aux membres de la classe en utilisant une fonction membre ;

Exemple :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    class Voiture
                                    {
                                    private:
                                        int Id;
                                        double Vitesse;
                                    
                                    public:
                                        // constructeur par défaut
                                        Voiture() : Id(0), Vitesse(0) {}

                                        void rouler(double);
                                    
                                        void setId(int id) // Setter de Id
                                        {
                                            Id = id;
                                        }
                                        int getId() // getter de Id
                                        {
                                            return Id;
                                        }
                                    
                                        void setVitesse(double v) // Setter de Vitesse
                                        {
                                            Vitesse = v;
                                        }
                                        double getVitesse() // getter de Vitesse
                                        {
                                            return Vitesse;
                                        }
                                    };
                                    
                                    int main()
                                    {
                                        Voiture v;
                                        v.setId(2);
                                        v.setVitesse(300.45);
                                        cout << "Id = " << v.getId() << "  -  Vitesse = " << v.getVitesse() << endl;
                                        return 0;
                                    }
                            
Id = 2 - Vitesse = 300.45

Les fonctions membres peuvent être définies dans la définition de classe ou séparément à l'aide de l'opérateur de résolution de portée " :: ".

Pour définir la fonction en dehors de la classe, nous pouvons utiliser la syntaxe suivante:

                                type_retour nomClass:: nomFonction(liste des paramètres){
                                    // corps de la fonction
                                }
                            
Exemple :

Par exemple, pour définir la fonction "rouler()", nous utilisons le code suivant

                                void Voiture::rouler(double v){
                                    Vitesse += v;
                                }
                            

L'usage standard d'une classe est de séparer la déclaration de la classe de la définition. La déclaration de la classe sera donc dans un fichier .h et la définition sera dans un fichier .cpp.

                                    // voiture.h
                                    class Voiture
                                    {
                                    private:
                                        int Id;
                                        double Vitesse;
                                    
                                    public:
                                        Voiture();
                                        void rouler(double);
                                        void setId(int);
                                        void setVitesse(double);
                                        int getId();
                                        double getVitesse();
                                    };
                            
                                    #include <iostream>
                                    #include "voiture.h" // inclure le fichier .h dans le fichier .cpp
                                    using namespace std;
                                    
                                    Voiture::Voiture()
                                    {
                                        Id = 0;
                                        Vitesse = 0;
                                    }
                                    void Voiture::setId(int a)
                                    {
                                        Id = a;
                                    }
                                    void Voiture::setVitesse(double v)
                                    {
                                        Vitesse = v;
                                    }
                                    int Voiture::getId() { return Id; }
                                    double Voiture::getVitesse() { return Vitesse; }
                                    
                                    void Voiture::rouler(double v)
                                    {
                                        Vitesse += v;
                                    }
                                    
                                    int main()
                                    {
                                        Voiture v;
                                        v.setId(2);
                                        v.setVitesse(300.45);
                                        cout << "Id = " << v.getId() << "  -  Vitesse = " << v.getVitesse() << endl;
                                        return 0;
                                    }
                            
Id = 2 - Vitesse = 300.45

Pointeur this

Chaque objet en C ++ a accès à sa propre adresse via un pointeur important appelé ce pointeur. Le pointeur this est un paramètre implicite pour toutes les fonctions membres. Par conséquent, dans une fonction membre, cela peut être utilisé pour faire référence à l'objet appelant.

Voici les situations où le pointeur "this" est utilisé :

  •  Lorsque le nom de la variable locale est identique au nom du membre :
                                                class Point{
                                                    private:
                                                        int x,y;
                                                    public:
                                                        Point(int x, int y){
                                                            this->x = x;
                                                            this->y = y;
                                                        }
                                                };
                                        
  •  Pour renvoyer une référence à l'objet appelant
                                                class Point{
                                                    private:
                                                        int x,y;
                                                    public:
                                                        Point(int x, int y){
                                                            this->x = x;
                                                            this->y = y;
                                                        }
                                                        void afficher(){
                                                            cout<< x << endl;
                                                        }
    
                                                        // retourner une référence vers l'objet appelant
                                                        Point& moi(){
                                                            return *this;
                                                        }
                                                };
                                        

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :