"Durée de vie" d'une chaîne littérale en C

Question

Le pointeur retourné par la fonction suivante ne serait-il pas inaccessible?

char *foo(int rc)
{
    switch (rc)
    {
        case 1:

            return("one");

        case 2:

            return("two");

        default:

            return("whatever");
    }
}

Donc, la durée de vie d'une variable locale en C/C++ est pratiquement seulement à l'intérieur de la fonction, n'est-ce pas? Ce qui signifie qu'après que char* foo(int) se termine, le pointeur qu'il retourne ne signifie plus rien, n'est-ce pas?

Je suis un peu confus quant à la durée de vie d'une variable locale. Quelle est une bonne clarification?

Answer 1

Oui, la durée de vie d'une variable locale est dans la portée({,}) dans laquelle elle est créée.

Les variables locales ont un stockage automatique ou local. Automatique car elles sont automatiquement détruites une fois que la portée dans laquelle elles sont créées se termine.

Cependant, Ce que vous avez ici est une chaîne littérale, qui est allouée dans une mémoire en lecture seule définie par l'implémentation. Les chaînes littérales sont différentes des variables locales et restent en vie tout au long de la durée du programme. Elles ont une durée de vie statique [Réf 1].

Un avertissement!

Cependant, notez que toute tentative de modifier le contenu d'une chaîne littérale est un comportement indéfini (CI). Les programmes utilisateur ne sont pas autorisés à modifier le contenu d'une chaîne littérale.
Il est donc toujours conseillé d'utiliser un const lors de la déclaration d'une chaîne littérale.

const char*p = "chaine"; 

au lieu de,

char*p = "chaine";    

En fait, en C++, il est déconseillé de déclarer une chaîne littérale sans le const bien que ce ne soit pas le cas en C. Cependant, déclarer une chaîne littérale avec un const vous donne l'avantage que les compilateurs vous donneraient généralement un avertissement en cas de tentative de modifier la chaîne littérale dans le deuxième cas.

Programme d'exemple:

#include 
int main() 
{ 
    char *str1 = "chaine littérale"; 
    const char *str2 = "chaine littérale"; 
    char source[]="Chaine d'exemple"; 

    strcpy(str1,source);    // Pas d'avertissement ou d'erreur juste un Comportement Indéfini 
    strcpy(str2,source);    // Le compilateur émet un avertissement 

    return 0; 
} 

Sortie:

cc1: les avertissements sont traités comme des erreurs
prog.c: Dans la fonction 'main':
prog.c:9: erreur: le passage de l'argument 1 de 'strcpy' ignore les qualificateurs du type cible du pointeur

Remarquez que le compilateur avertit pour le deuxième cas, mais pas pour le premier.

---

Pour répondre à la question posée par quelques utilisateurs ici:

Qu'en est-il des littéraux intégraux?

En d'autres termes, le code suivant est-il valide?

int *foo()
{
    return &(2);
} 

La réponse est non, ce code n'est pas valide. Il est mal formé et provoquera une erreur du compilateur.

Quelque chose comme:

prog.c:3: erreur: une l-value est requise comme opérande «&» unaire

Les chaînes littérales sont des l-value, c'est-à-dire: Vous pouvez prendre l'adresse d'une chaîne littérale, mais ne pouvez pas changer son contenu.
Cependant, tout autre littéral (int, float, char, etc.) sont des r-values (le standard C utilise le terme la valeur d'une expression pour ceux-ci) et leur adresse ne peut être prise du tout.

---

[Réf 1]Standard C99 6.4.5/5 "Chaînes littérales - Sémantique":

Dans la phase de traduction 7, un octet ou un code de valeur zéro est ajouté à chaque séquence de caractères multioctets qui résulte d'une ou de plusieurs chaînes littérales. La séquence de caractères multioctets est ensuite utilisée pour initialiser un tableau de durée de stockage statique et de longueur juste suffisante pour contenir la séquence. Pour les littéraux de chaîne de caractères, les éléments du tableau ont le type char, et sont initialisés avec les octets individuels de la séquence de caractères multioctets; pour les littéraux de chaîne large, les éléments du tableau ont le type wchar_t, et sont initialisés avec la séquence des caractères larges...

Il n'est pas spécifié si ces tableaux sont distincts tant que leurs éléments ont les valeurs appropriées. Si le programme tente de modifier un tel tableau, le comportement est indéfini.

Answer 2

C'est valide. Les littéraux de chaîne ont une durée de stockage statique, donc le pointeur n'est pas invalide.

Pour le langage C, cela est prescrit dans la section 6.4.5, paragraphe 6 :

En phase de traduction 7, un octet ou un code de valeur zéro est ajouté à chaque séquence de caractères multioctets qui résulte d'un ou plusieurs littéraux de chaîne. La séquence de caractères multioctets est ensuite utilisée pour initialiser un tableau de durée de stockage statique et de longueur juste suffisante pour contenir la séquence.

Et pour le langage C++ dans la section 2.14.5, paragraphes 8-11 :

8 Les littéraux de chaîne ordinaires et les littéraux de chaîne UTF-8 sont également appelés littéraux de chaîne étroite. Un littéral de chaîne étroite a le type "tableau de n const char", où n est la taille de la chaîne telle que définie ci-dessous, et a une durée de stockage statique (3.7).

9 Un littéral de chaîne qui commence par u, comme u"asdf", est un littéral de chaîne de char16_t. Un littéral de chaîne de char16_t a le type "tableau de n const char16_t", où n est la taille de la chaîne telle que définie ci-dessous ; il a une durée de stockage statique et est initialisé avec les caractères donnés. Un unique c-char peut produire plus d'un caractère char16_t sous forme de paires de remplacement.

10 Un littéral de chaîne qui commence par U, comme U"asdf", est un littéral de chaîne de char32_t. Un littéral de chaîne de char32_t a le type "tableau de n const char32_t", où n est la taille de la chaîne telle que définie ci-dessous ; il a une durée de stockage statique et est initialisé avec les caractères donnés.

11 Un littéral de chaîne qui commence par L, comme L"asdf", est un littéral de chaîne large. Un littéral de chaîne large a le type "tableau de n const wchar_t", où n est la taille de la chaîne telle que définie ci-dessous ; il a une durée de stockage statique et est initialisé avec les caractères donnés.

Answer 3

Les littéraux de chaîne sont valides pour l'ensemble du programme (et ne sont pas alloués sur la pile), donc ils seront valides.

Aussi, les littéraux de chaîne sont en lecture seule, donc (pour une bonne pratique) vous devriez peut-être changer foo en const char *foo(int)

Answer 4

Oui, c'est un code valide, voir le cas 1 ci-dessous. Vous pouvez renvoyer en toute sécurité des chaînes C à partir d'une fonction de au moins ces façons:

• const char* à une chaîne littérale. Il ne peut pas être modifié et ne doit pas être libéré par l'appelant. Il est rarement utile dans le but de renvoyer une valeur par défaut, en raison du problème de libération décrit ci-dessous. Cela pourrait avoir du sens si vous avez vraiment besoin de passer un pointeur de fonction quelque part, donc vous avez besoin d'une fonction renvoyant une chaîne.

• char* or const char* à un tampon char statique. Il ne doit pas être libéré par l'appelant. Il peut être modifié (soit par l'appelant s'il n'est pas const, soit par la fonction le renvoyant), mais une fonction renvoyant cela ne peut pas avoir (facilement) plusieurs tampons, donc ce n'est pas (facilement) thread-safe, et l'appelant peut avoir besoin de copier la valeur renvoyée avant d'appeler à nouveau la fonction.

• char* à un tampon alloué avec malloc. Il peut être modifié, mais il doit généralement être explicitement libéré par l'appelant et a le surdébit d'allocation de la mémoire. strdup est de ce type.

• const char* or char* à un tampon, qui a été passé en argument à la fonction (le pointeur renvoyé ne doit pas pointer vers le premier élément du tampon d'argument). Cela laisse la responsabilité de la gestion du tampon/mémoire à l'appelant. De nombreuses fonctions de chaînes standard sont de ce type.

Un problème est, mélanger ceux-ci dans une fonction peut devenir compliqué. L'appelant doit savoir comment gérer le pointeur renvoyé, combien de temps il est valide, et si l'appelant doit le libérer, et il n'y a aucun moyen (agréable) de le déterminer à l'exécution. Donc vous ne pouvez pas, par exemple, avoir une fonction, qui renvoie parfois un pointeur vers un tampon alloué dans le tas que l'appelant doit free, et parfois un pointeur vers une valeur par défaut d'une chaîne littérale, que l'appelant ne doit pas free.

Answer 5

Bonne question. En général, tu aurais raison, mais ton exemple est l'exception. Le compilateur alloue statiquement de la mémoire globale pour une chaîne littérale. Par conséquent, l'adresse retournée par ta fonction est valide.

C'est d'ailleurs une fonctionnalité assez pratique de C, n'est-ce pas? Cela permet à une fonction de renvoyer un message précomposé sans obliger le programmeur à se soucier de la mémoire dans laquelle se trouve le message.

Voir également l'observation correcte de @asaelr concernant const.