Incrémentation à l'aide de fonctions

Vous transmettez toujours une copie de votre variable, valeur ou référence à la fonction. Ainsi, l'envoi d'une copie de la valeur n'affectera pas la fonction main . Cependant, l'envoi d'une copie de sa référence affectera la fonction main car vous dites où se trouve votre variable dans la mémoire.

Toujours dans la deuxième méthode, pourquoi passons-nous l'argument comme adresse, c'est-à-dire & a. Pourquoi ne pouvons-nous pas le faire passer pour un?

Vous êtes ici en train de manipuler avec un pointeur, lorsque vous changez la valeur d'adresse en ce pointeur, la valeur d'origine est également modifiée.

En revanche, lorsque vous passez la variable un par valeur, il fera juste une copie et l'incrémentera dans l'appel de fonction, aucune modification ne se produira dans la valeur d'origine. La première méthode ne fonctionne pas car la variable passée dans la fonction était de type passe-par-valeur.

Modifier: Cette question n'est désormais balisée qu'en C. Mais pour plus information, il existe une méthode pour le faire sans pointeurs en C ++, elle est appelée pass-by-reference (manipule avec la copie originale des variables) qui pourrait être représentée par une esperluette sur la signature de la fonction, quelque chose comme:

void changeRealValue(int& value) {
// _____________________^________
    value++; // original value is incremented now
}

Pointer est une variable contenant l'adresse d'un objet. Le pointeur ne porte pas d'informations sur le contenu de l'objet, mais contient des informations sur l'emplacement de l'objet.

Les pointeurs sont largement utilisés dans la programmation C. Les pointeurs sont souvent utilisés lorsque vous travaillez avec des tableaux.

La mémoire de l'ordinateur peut être considérée comme une séquence de cellules numérotées à un octet auxquelles on peut accéder individuellement ou par blocs.

Chaque variable dans la mémoire a sa propre adresse - le numéro de la première cellule où elle se trouve, ainsi que sa valeur. Un pointeur est également une variable allouée en mémoire. Il a également une adresse et sa valeur est l'adresse d'une autre variable. Une variable déclarée comme un pointeur occupe 4 octets en RAM (dans le cas d'une version 32 bits du compilateur).

Un pointeur, comme toute variable, doit être déclaré .

#include <stdio.h>
#include <stdlib.h>
int main()
{
  int a, *b;
  system("chcp 1251");
  system("cls");
  a = 134;
  b = &a;
  // %x = display the number in hexadecimal form
  printf("\n The value of the variable a is %d = %x hex.", a,a);
  printf("\n The address of the variable a is %x hex.", &a);
  printf("\n Data at pointer address b are equal %d = %x hex.", *b,*b);
  printf("\n The value of b pointer is %x hex.", b);
  printf("\n Location address of pointer b is %x hex.", &b);
  getchar();
  return 0;
}

Regardez cet exemple:

сhar c;   // variable
char *p; // pointer
p = &c;  // p = address of c

Le problème est que par défaut, c utilise le passage par valeur pour les fonctions. Cela signifie que si vous appelez la fonction de la manière suivante dans votre main,

#include<stdio.h>
void inc(int v)
{
    v++;
    return v
}

int main()
{
    int a;
    scanf("%d",&a);
    a = inc(a);
    printf("%d",a);
    return 0;
}

la fonction ne connaît que la valeur 45 mais pas la variable a. Il va donc créer une nouvelle variable locale (int v dans votre cas) qui stocke la valeur 45 et s'incrémente. Puisque la fonction ne sait rien de a, en particulier pas où a est situé en mémoire, elle ne peut pas le modifier. Il existe généralement deux façons de résoudre ce problème:

1. Utilisation des retours:

Dans ce cas, la fonction continue de manipuler une copie locale avec les valeurs des arguments passés. En fin de compte, il peut renvoyer la sortie souhaitée de la fonction. Cela serait mis en œuvre de la manière suivante:

int a = 45;
inc(a);

2. Passer l'argument comme pointeur:

Dans le second cas, que vous avez déjà trouvé, vous passez votre argument par référence. De cette façon, la fonction apprend à connaître l'adresse mémoire de a et peut donc manipuler directement la valeur stockée à a. La petite icône en forme d'étoile à côté de v dans la définition de la fonction void inc (int * v) définit que la fonction prend une adresse comme entrée. Par conséquent, vous devez passer l'adresse d'un en utilisant & a comme cela est fait dans le code que vous avez publié.

Résumé:

Votre fonction, ou tout futur les fonctions que vous implémentez peuvent être de l'un des deux types ci-dessus selon vos besoins. Il doit cependant, à titre indicatif, ne jamais manipuler les valeurs aux adresses passées et renvoyer quelque chose en même temps. Cela peut prêter à confusion et entraîner un code moins lisible en général.

"Pourquoi la méthode sans pointeurs n'est-elle pas correcte?"

Si vous utilisez un paramètre de pointeur, votre intention est de pointer vers un objet dans l'appelant. Vous pouvez ensuite modifier cet objet dans la fonction appelée. C'est ce que l'on appelle le passe par référence . Vous passez une référence à un objet dans l'appelant.

Si vous n'utilisez pas de pointeur, vous passez simplement la valeur de la variable par valeur à la fonction, ce qui signifie que la valeur de l'argument est affectée à une variable locale de fonction. À l'intérieur de la fonction, vous ne pouvez modifier que la valeur de cette variable locale de la fonction, mais pas un objet dans l'appelant.

Quelle est la différence entre passer par référence et passer par valeur?

Toujours dans la deuxième méthode, pourquoi passons-nous l'argument comme adresse, c'est-à-dire & a . Pourquoi ne pouvons-nous pas le passer comme a ? "

L'opérateur & gagne dans ce cas l'adresse de a , qui doit être affectée au paramètre pointeur.

Un pointeur stocke toujours l'adresse d'un objet vers lequel pointer, pas une valeur de l'objet pointé.

Sans adresse, le pointeur ne désigne pas un objet.

Réponse courte:

C est le passage par valeur par défaut. Si le pointeur n'est pas spécifié, un v dans inc est juste une copie de a dans main avec la même valeur .

Autrement dit, v ++ augmenterait v dans la portée de inc mais n'en affecterait aucun autre.

Pour le pointeur, (* v) ++ signifie "ajouter une valeur à l'endroit où v pointe vers"

Si vous utilisez C ++, la transmission par référence est une autre solution.