Passer par référence en C

Je suis en train d'utiliser passage par référence en C de manière à ce que la fonction peut modifier les valeurs des paramètres qui lui sont passés. C'est la signature de la fonction:

int locate(char *name, int &s, int &i)

Cependant lorsque j'essaie de compiler, j'obtiens cette erreur qui se réfère spécifiquement à la ligne ci-dessus:

erreur:‘;’,‘, ’ ou de ‘)’ avant
'&' token

Si je supprime le "& " le programme compile, mais il ne fonctionne pas correctement, évidemment. Quel est le problème ici? Comment puis-je faire appel par la référence au travail?

source d'informationauteur neuromancer

  1. 35

    C n'a pas de références. Vous avez besoin de passer un pointeur vers la variable que vous souhaitez modifier:

    int locate(char *name, int *s, int *i)
{
    /* ... */

    *s = 123;
    *i = 456;
}

int s = 0;
int i = 0;
locate("GMan", &s, &i);

/* s & i have been modified */
  2. 20

    C n'a pas de référence à des variables mais vous pouvez envisager d'référence const pointeur vers les données de sorte ,

    Faire const pointeur vers les données comme cela pour que le pointeur de cant point à d'autres données, mais les données se faire remarquer par elle peut être changée.

    int  locate (char *name,  int  * const s, int * const i)
  3. 7

    C ne supporte pas le passage par référence. Vous aurez besoin de C++ pour faire de la manière dont elle est écrite, ou modifier dans

    int locate(char *name, int *s, int *i)

    et de passer des pointeurs de la deuxième et de la troisième paramètre des variables.

  4. 2

    Le plus tôt réponses semblent manquer de contexte, et de ne pas traiter de la propriété que C les pointeurs sont surchargés. Il est tout à fait juste de prétendre que C "passe par une référence." Un pointeur est une référence, aussi. Cependant, plus formellement, un C "de référence" est le mécanisme pour représenter un symbole de l'adresse de mémoire.

    • Un pointeur est simplement une variable en mémoire, dont la valeur est considérée comme un
      adresse.
    • Une référence est tout simplement, la valeur littérale pour une adresse de mémoire.
    • Le langage C permet le passage par référence - mais seulement dans le bon contexte!

    La séparation de contexte est celui de la signature de la définition et de la signature de l'invocation.

    Considérer les primitives int a = 0x22e8; et ailleurs, nous déclarons int* b = &a; (je vais prendre des fonctions dans une minute).

    Nous avons pu observer cela en mémoire (à supposer boutisme n'a pas d'importance pour cet exemple):

    ...
0x00000200:        22e8        ; this is the variable for int a's literal value:
                               ; a == 0x000022e8
                               ; &a == 0x00000200
0x00000???:        9090        ; ... more code ...
0x00000400:        0200        ; this is pointer b pointing to a's address:
                               ; b == 0x00000200
                               ; *b == 0x000022e8
                               ; &b == 0x00000400
...

    Il est facile de voir que l'on peut affecter un pointeur vers n'importe quelle adresse sans des astuces. Un pointeur est une variable, mais C nous permet de référencer l'adresse de pointage; nous pouvons "déréférencer le pointeur de la valeur de l'adresse au lieu de traiter le pointeur comme son pointee de la valeur sous-jacente au cours d'un contexte d'invocation: while ( *b == a ) .... On pourrait aisément appeler b == &a.

    Lors de l'application pour les appels de fonction, vous devez séparer le contexte de la fonction (signature) définition vs invocation afin de différencier les passer par référence.

    int* foo(int* blah, int nah) { .. }     //signature definition context:
                                        //These are parameters
... vs ...

b = foo( &a, 4);                        //invocation context:
                                        //These are arguments

    Dans la définition d'une signature de fonction, nous n'allons pas dire que le compilateur qui adresse un argument est accessible à partir de — le moteur d'exécution ne sait même pas encore! C'est tout simplement absurde de définir void bar(int &blah) {...}. Au lieu de cela, nous utilisons le pointeur déréférencé de la syntaxe "quelle que soit l'argument est passé en sera chargé à l'adresse pointée" référence souhaitée valeur d'argument lors de l'exécution se produit. Donc C peut passer des arguments par référence.

    Les contextes à la fois la fonction de la signature des définitions et des appels de fonction modifier la façon dont le compilateur recherche pointeur de la surcharge vs de référence, et comment le runtime peut effectivement traiter.

  5. 1

    Vous ne pouvez pas le faire en c. c n'a pas de référence, vous pouvez utiliser le pointeur de la place.

  6. 1

    Si vous souhaitez utiliser le passage par référence méthode pour modifier un paramètre dans l'appel de fonction, toujours utiliser des pointeurs comme arguments formels de la fonction.

    Donc au lieu d'utiliser ce

    int locate(char *name, int &s, int &i)

    utilisation, 

    int locate(char *name, int *s, int *i)

    Lorsque vous appelez cette fonction, vous pouvez utiliser

    .........

    int a=5;
int d=10;
char c='A'; 
int result;

result=locate(&c, &a, &d);

    J'espère que tout serait clair maintenant,

    Pour plus d'idée sur la transmission par valeur ou le passage par référence et lequel est le mieux, cette source est bon pour les débutants

    http://www.learnc.net/call-by-reference.php

    Avoir du plaisir.

  7. 0

    (Je suis ont été à l'aide de C pour un moment, mais je suis encore nouveau pour quelques concepts en C. je suis en tentant d'y répondre au meilleur de ma connaissance, n'hésitez pas à me corriger Si je me trompe)

    Quand vous dites passage par référence vous passer l'adresse, et ne vous serait d'utiliser des pointeurs pointant vers les adresses. Si vous avez besoin de passer les pointeurs pour votre prototype de fonction, mais ce que vous êtes en train de faire est de passer directement l'adresse.

    Ce que votre fonction essaie de référence(à l'aide de &) le pointeur de la souris, mais vous n'avez jamais eu un pointeur sur paramètres " s " et " i " de référence.

    La bonne façon de faire pour le prototype de fonction/définition est

    int locate(char *name, int *s, int *i)

    et lorsque vous devez appeler cette fonction, vous pouvez utiliser la déclaration ci-dessous dans la principale ou la fonction d'appel

    int locate(char *name, &s, &i)