Wie funktioniert die Funktion scanf Arbeit in C?

Warum benötigen Sie kaufmännisches und-Zeichen (&) in der scanf Funktion. Was wird der Ausgang oder die Art der Fehler (compile-oder Laufzeit) werden in der folgenden C-code?

#include <stdio.h>

void main() {
    int a;
    printf("enter integer:");
    scanf("%d", a);
}

Nebenbei main zurück int, nicht void.

InformationsquelleAutor Amol Aggarwal | 2010-01-14

c scanf

12

Den & in C ein operator ist, gibt die Adresse des Operanden. Denken Sie an es auf diese Weise, wenn Sie geben einfach scanf die variable a ohne die & ist, wird es an es übergeben werden, indem-Wert, was bedeutet, dass scanf wird nicht in der Lage sein, Ihren Wert für Sie zu sehen. Übergabe per Referenz (using & tatsächlich übergibt einen Zeiger auf a) ermöglicht scanf es so eingerichtet, dass der Aufruf von Funktionen, die Veränderung sehen, die auch.

In Bezug auf die spezifischen Fehler, kann man nicht wirklich sagen. Das Verhalten ist undefiniert. Manchmal könnte es stillschweigend weiter laufen, ohne dass Sie wissen scanf verändert einige Werte, die irgendwo in Ihrem Programm. Manchmal wird das Programm Abstürzen, sofort, wie in diesem Fall:
```
#include <stdio.h>
int main()
{
    int a;
    printf("enter integer: ");
    scanf("%d",a);
    printf("entered integer: %d\n", a);
    return 0;
}
```
Kompilieren zeigt er das an:
```
$ gcc -o test test.c
test.c: In function ‘main’:
test.c:6: warning: format ‘%d’ expects type ‘int *’, but argument 2 has type ‘int’
```
Und die Ausführung zeigt einen segmentation fault:
```
$ ./test 
enter integer: 2
Segmentation fault
```
InformationsquelleAutor abyx
3

In C, alle Funktions-Argumente als Wert übergeben werden; änderungen an der Funktion formale parameter sind, spiegelt sich nicht in der tatsächlichen parameter. Zum Beispiel:
```
void foo(int bar)
{
  bar = bar + 1;
}

int main(void)
{
  int x = 0;
  printf("x before foo = %d\n", x);
  foo(x);
  printf("x after foo = %d\n", x);
  return 0;
}
```
Die Ausgabe des Programms wird
```
x vor foo = 0 
x nach foo = 0 
```
weil bar erhält den Wert x (0), nicht eine Referenz auf x selbst. Ändern bar hat keine Auswirkungen auf x.

In C, der Weg, um dieses ist zum übergeben eines Zeiger zu einer variable:
```
void foo(int *bar)
{
  *bar = *bar + 1;
}

int main(void)
{
  int x = 0;
  printf("x before foo = %d\n", x);
  foo(&x);
  printf("x after foo = %d\n", x);
  return 0;
}
```
Nun die Ausgabe des Programms ist
```
x vor foo = 0 
x nach foo = 1 
```
Dieser Zeit werden die formalen parameter bar ist nicht eine int, aber eine Zeiger int, und es erhält die Adresse von x (gegeben durch den Ausdruck &x im Aufruf foo), nicht die enthaltenen Wert in x. Der Ausdruck *bar Mittel ", um den Wert in der Adressleiste Punkte zu", so *bar = *bar + 1 entspricht x = x + 1.

Seit scanf() schreiben muss, um seine Argumente, es erwartet, dass diese Argumente nicht zu toppen als Zeiger. Die "%d" umwandlungsspezifikator erwartet, dass das zugehörige argument ein Zeiger auf int (int *), die "%u" umwandlungsspezifikator erwartet einen Zeiger auf unsigned int (unsigned *), "%s" erwartet einen Zeiger auf char (char *), "%f" erwartet einen Zeiger auf float (float *), etc. In deinem Beispiel, da a eingegeben wird int benutzen, brauchen Sie den Ausdruck &a einen Zeiger.

Beachten Sie, dass, wenn a waren bereits ein pointer-Typ, würden Sie nicht brauchen, um verwenden Sie die & Betreiber im Aufruf scanf():
```
int main(void)
{
  int a, *pa;      //declare pa as a pointer to int
  ...
  pa = &a;         //assign address of a to pa
  scanf("%d", pa); //scanf() will write to a through pa
  ...
}
```
Beachten Sie auch, dass bei der übergabe eines Arrays an eine Funktion (wie bei der Verwendung der "%s" umwandlungsspezifikator zu Lesen, dass ein string), die Sie nicht brauchen, um verwenden Sie die & operator; die array-Ausdrucks implizit umgewandelt werden in ein Zeiger-Typ:
```
int main(void)
{
  char name[20];
  ...
  scanf("%19s", name); //name implicitly converted from "char [20]" to "char *"
  ...
}
```
InformationsquelleAutor John Bode
2

Wenn Sie Fragen, eine Frage wie diese, würde ich empfehlen, nur zu lernen, für jetzt "es funktioniert einfach".

Erfahren Sie, dass müssen Sie ein kaufmännisches und-Zeichen, weil scanf nimmt eine oder mehrere pointer-Argumente. Wenn a eine int-variable ist, ist es nicht ein Zeiger. &a ("Adresse von a") ist ein Zeiger, so funktioniert es mit scanf.

InformationsquelleAutor Jon
2

Dies ist, weil in C, Funktionen Parameter sind durch Wert übergeben. Um für die scanf() - Funktion zum ändern der ' a ' - variable in der main () - Funktion, die Adresse von 'a' zuteil werden soll scanf(), damit die Nutzung des et-Zeichens (Adresse).

InformationsquelleAutor philant
1

Weil scanf erfordert ein Zeiger auf die variable (also eine Referenz), dass der Wert in.

InformationsquelleAutor Mitch Wheat
1

Du nicht immer benutzen müssen & mit scanf. Was Sie tun müssen, ist zu gehen Zeiger. Wenn Sie neu in C, sollten Sie verbringen einige Zeit mit dem Lesen der comp.lang.c FAQ:

http://c-faq.com/

Speziell:
- Warum nicht den Aufruf scanf("%d", i) arbeiten?
- Warum funktioniert der Aufruf scanf("%s", s) arbeiten?
InformationsquelleAutor jamesdlin
0

Dem '&' in scanf ist nur erforderlich, um die Adresse einer Variablen. Sie kann Verwendung scanf ohne '&' durch verwenden von Zeigern:
```
int myInt;
int * pointer_to_int;
pointer_to_int = &myInt;
scanf("%d", pointer_to_int);
```
Im Allgemeinen mit '&' ist oft einfacher als das erstellen Zeiger zu vermeiden, die mit dem '&'.

InformationsquelleAutor Thomas Matthews

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.