Cas d'Utilisation des Références

Les références sont comme les héros méconnus de C++. Elles fournissent un alias aux objets existants, ce qui aide à alimenter divers cas d'utilisation avancés, tout en assurant la clarté du code. Pour vraiment maîtriser la gestion de la mémoire, il est important de apprendre et respecter les références autant que les pointeurs intelligents.

Éviter les copies inutiles pour les paramètres de fonction

Les références sont le plus souvent utilisées pour optimiser les paramètres de fonction. Lorsque vous passez un argument par référence à une fonction, vous évitez la surcharge des copies inutiles. Cela est particulièrement utile lors de la manipulation de grands objets. Lorsqu'il est fait tout au long de votre programme, passer des arguments par référence peut conduire à une optimisation substantielle de la mémoire et des performances.

Dans cet exemple, nous concaténons deux chaînes sans encourir le coût de la création de leurs copies. Au lieu de cela, nous utilisons des références pour travailler directement avec les objets originaux, et retournons une nouvelle chaîne concaténée depuis la fonction. La fonction peut être appelée comme suit :

Retourner plusieurs valeurs

Les références permettent aux fonctions de retourner plusieurs valeurs. Alors que les fonctions C++ retournent généralement une seule valeur, l'utilisation de références permet aux fonctions de modifier les paramètres de référence comme moyen de retourner plusieurs valeurs à l'appelant. Considérez l'exemple suivant pour plus de clarté :

main


              123456789101112131415161718192021
            
#include <vector>

// function that returns the minimum and maximum values of a vector of integers
// both the minimum and maximum values will be returned via references
// boolean flag will also be returned from the function body
bool findMinMax(const std::vector<int>& numbers, int& min, int& max) {
    if (numbers.empty())
        return false;  // no values to find
        
    // initializing min and max with the first element of the vector
    min = max = numbers[0]; 
    // the following for loop calculates the minimum and maximum values
    for (int num : numbers) {
        if (num < min)
            min = num; // update min if num is smaller
        if (num > max)
            max = num; // update max if num is larger
    }
    // at this stage, the min and max reference variables will hold relevant values for the caller
    return true; // indicating successful calculation of min and max
}

Dans le code ci-dessus, nous utilisons la puissance des références pour retourner à la fois les valeurs minimales et maximales d'un vecteur à l'appelant. Après le retour de la fonction, l'appelant trouvera que les deux variables de référence contiennent respectivement les valeurs minimales et maximales correctes.

Sécurité contre les null

Les références offrent un degré de sécurité contre les null que l'on ne trouve pas dans les pointeurs. Contrairement aux pointeurs, les références ne peuvent pas être définies sur null. Cela signifie que lorsque vous déclarez une référence, elle doit être initialisée avec une valeur valide, et elle ne peut pas non plus être explicitement définie sur Null. Par exemple, le code suivant n'est pas autorisé :

Cependant, il y a une mise en garde importante à retenir. Même si les références ne peuvent pas être explicitement définies sur null, elles peuvent toujours "devenir null" en pratique. Cela peut se produire lorsque vous créez par inadvertance une référence à un objet qui a été supprimé ou qui est sorti de la portée. Considérez cet extrait de code :

main


              1234567891011121314
            
#include <iostream>

int main() 
{
    int* ptr = new int(42); // dynamically allocate an integer
    int& ref = *ptr; // create a reference to the allocated integer

    delete ptr; // deallocate the memory

    // at this point, ref has become a null reference because the object it referred to has been deleted.
    // accessing ref now would result in undefined behavior.
    // this line may cause a runtime error.
    std::cout << "Value through ref: " << ref << std::endl; 
}

Dans le code ci-dessus, nous avons créé en toute sécurité une référence à un entier dynamique. Plus tard, cet entier est désalloué lorsque nous appelons l'opérateur delete sur le pointeur. Cela provoque la nullité de la référence.

Pointeurs vs références

Les pointeurs et les références sont deux outils puissants en C++ avec des cas d'utilisation spécifiques. En tant que programmeur C++ ingénieux, il est important de savoir quand utiliser chacun.

Utilisez les pointeurs lorsque vous souhaitez pointer vers différents objets, ou lorsque vous souhaitez représenter l'absence d'un objet avec null. Les pointeurs sont polyvalents et offrent plus de flexibilité dans la gestion de la mémoire dynamique.
Les références sont généralement utilisées dans des scénarios où vous souhaitez travailler directement avec des objets existants, sans effectuer de copie ou de réaffectation. Comme mentionné dans les titres ci-dessus, utilisez les références lorsque vous devez passer des arguments à des fonctions sans le surcoût de la copie, retourner plusieurs valeurs de fonctions, ou lorsque vous souhaitez une sécurité null.

Nous approfondirons les différences entre les pointeurs et les références dans une section ultérieure.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 4