En passant le pointeur de l'argument par référence en C?

#include <stdio.h>
#include <stdlib.h>

void
getstr(char *&retstr)
{
 char *tmp = (char *)malloc(25);
 strcpy(tmp, "hello,world");
 retstr = tmp;
}

int
main(void)
{
 char *retstr;

 getstr(retstr);
 printf("%s\n", retstr);

 return 0;
}

gcc ne serait pas compiler ce fichier, mais après l'ajout #include <cstring> je pourrais utiliser g++ pour compiler ce fichier source.

Le problème est: est-ce le langage de programmation C en charge la transmission de pointeur en argument par référence? Si non, pourquoi?

Grâce.

Pas liés à votre question, mais pour la curiosité, ce qui est le cas pour le passage d'un pointeur comme une référence?
si vous souhaitez que la fonction pour être en mesure de modifier le pointeur, et avoir la modification se propager au-delà de la portée de la fonction.
Si vous souhaitez effectuer malloc de chaînes dans une fonction qui n'a pas d'espace libre de la mémoire alors vous pourriez envisager d'utiliser valgrind ou l'équivalent de l'outil de test de fuites de mémoire.
Une référence est une façon de confondre les programmeurs de ce qui se passe vraiment. Si vous la discipline de votre approche de pointeurs, vous trouverez que les références ne sont pas nécessaires. Lorsque vous traitez avec une référence à un compilateur est de prendre des mesures sur un objet et de la gestion de l'indirection pour vous.
PP: simplification grossière de références; toute fonction peut être utilisée abusivement.

OriginalL'auteur Jichao | 2009-12-01

  1. 29

    Non, C ne supporte pas les références. C'est par la conception. Au lieu de références vous pourriez utiliser un pointeur de pointeur dans C. Références sont disponibles uniquement en langage C++.

    OriginalL'auteur Kirill V. Lyadvinsky

  2. 20

    Les références sont une caractéristique de C++, tandis que le C prend en charge uniquement les pointeurs. Pour avoir votre fonction à modifier la valeur du pointeur, passer le pointeur vers le pointeur:

    void getstr(char ** retstr)
{
    char *tmp = (char *)malloc(25);
    strcpy(tmp, "hello,world");
    *retstr = tmp;
}

int main(void)
{
    char *retstr;

    getstr(&retstr);
    printf("%s\n", retstr);

    //Don't forget to free the malloc'd memory
    free(retstr);

    return 0;
}
    Ne pas jeter ce malloc() retourne. Si vous avez inclus stdlib.h, il ne fait absolument rien. Si vous ne l'avez pas, il se cache.
    Comme malloc retourne void* je trouve ça bien pratique pour lancer explicitement le type au lieu de compter sur les conversions implicites. Si stdlib.h n'est pas inclus, le casting ne cache pas que le compilateur va vous avertir que malloc n'a pas été déclaré.

    OriginalL'auteur Bojan Resnik

  3. 5

    Essayez ceci:

    
void
getstr(char **retstr)
{
 char *tmp = (char *)malloc(25);
 strcpy(tmp, "hello,world");
 *retstr = tmp;
}

int
main(void)
{
 char *retstr;

 getstr(&retstr);
 printf("%s\n", retstr);

 return 0;
}
    Ne lancez pas la valeur de retour de malloc. Il peut en cacher un défaut de #include <stdlib.h> (que vous n'avez oubliez le code ci-dessus). Voir c-faq.com/malloc/mallocnocast.html Aussi, n'oubliez pas de vérifier la valeur de retour de malloc.
    Wow, certaines personnes luttent pour voir la différence entre une preuve de concept routine de test et de production de code! Il était évident que c'était un rough-and-ready test de routine car il n'y avait pas de correspondant free mais j'imagine que certaines personnes négligent ce qui est évident!

    OriginalL'auteur PP.

  4. 2

    Cela devrait être un commentaire mais il est trop long pour une zone de commentaire, alors je le fais CW.

    Le code que vous avez fournies peuvent être mieux écrit que:

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>

void
getstr(char **retstr)
{
    *retstr = malloc(25);
    if ( *retstr ) {
        strcpy(*retstr, "hello,world");
    }
    return;
}

int
main(void)
{
    char *retstr;

    getstr(&retstr);
    if ( retstr ) {
        printf("%s\n", retstr);
    }
    return 0;
}

    OriginalL'auteur

  5. 1

    Il y a un truc intéressant dans libgmp qui émule les références:
    typedef mpz_t __mpz_struct[1];

    et puis vous pouvez l'écrire comme ceci:

    mpz_t n;
mpz_init(n);
...
mpz_clear(n);

    Je recommande de ne pas utiliser cette méthode, car il peut être incompréhensible pour les autres, elle ne vous protège pas d'être une valeur NULL: mpz_init((void *)NULL), et il est aussi bavard que son pointeur de pointeur de la contrepartie.

    OriginalL'auteur Dmytro Sirenko

  6. 0

    C lang n'a pas de référence à des variables, mais sa part de C++ lang.

    La raison de l'introduction de la référence est à éviter en balançant les pointeurs
    et la pré-vérification pour les pointeurs de nullité.

    Vous pouvez envisager de référence comme pointeur constant c'est à dire const pointeur ne peut pointer que les données qu'il a été initialisé à point.

    L'autre différence (en plus de l'syntaxique) est que les références ne peut pas être null.

    OriginalL'auteur Ashish