Kann mir jemand diesen Code erklären? Ich bin neu in C

Question

Ich versuche, C zu lernen, also ging ich, um einige der Coderbyte-Herausforderungen in C zu versuchen, von denen einer eine Zeichenfolge umzukehren ist. Nach gettung mehrere durch Kompilierungsfehlern Ich habe versucht, für Beispiele der Suche Syntax und stieß dieses auf http://www.programmingsimplified.com/c-program-reverse-string

#include<stdio.h> 

int string_length(char*); 
void reverse(char*); 

main() 
{ 
    char string[100]; 

    printf("Enter a string\n"); 
    gets(string); 

    reverse(string); 

    printf("Reverse of entered string is \"%s\".\n", string); 

    return 0; 

}

void reverse(char *string) 
    { 
     int length, c; 
     char *begin, *end, temp; 

     length = string_length(string); 
     begin = string; 
     end = string; 

     for (c = 0; c < length - 1; c++) 
     end++; 

     for (c = 0; c < length/2; c++) 
     {   
     temp = *end; 
     *end = *begin; 
     *begin = temp; 

      begin++; 
      end--; 
     } 
    } 

    int string_length(char *pointer) 
    { 
     int c = 0; 

    while(*(pointer + c) != '\0')//I DON'T UNDERSTAND THIS PART!!!!! 
     c++; 

    return c; 
} 

c ist nicht einmal ein Zeichen, also warum sollten Sie es hinzufügen? Oder ist der Zeiger eine Art Index, der den Kontext der while-Schleife berücksichtigt?

Answer 1

Von dem, was ich verstehe, wenn die Zeichenfolge: abcd das Ergebnis wäre: dcba , wenn der Eingang ist: HALLO-WORLD die Ausgabe wäre: DLROW-olleh

Answer 2

Denken Sie daran, dass *(pointer + c) äquivalent zu pointer[c] . c wird als Index verwendet.

Answer 3

Der Operator + bedeutet hier nicht Zeichenfolge Verkettung; es bedeutet Zeigerarithmetik. pointer ist ein Zeiger auf eine char und c ist ein int, so pointer + c ergibt einen Zeiger auf eine char die cchar s weiter nach vorne im Speicher befindet. Wenn Sie zum Beispiel ein Array {'j', 'k', 'l', 'm'} und pointer auf die 'j' zeigen und c 2, dann würde pointer + c auf die 'l' zeigen. Wenn Sie einen Zeiger wie diesen voranbringen, dann referenzieren Sie ihn, der genauso funktioniert wie die Array-Indizierungssyntax: pointer[c]. Die Schleife ist damit äquivalent zu:

while(pointer[c] != '\0') 
    c++; 

Die Wirkung eines Zeigers auf eine ganze Zahl Addieren (oder umgekehrt) skaliert entsprechend der Größe von dem, was sich der Zeiger (vermeintlich) zeigt auf, so kann man nicht tun müssen unterschiedliche Größen von Objekten berücksichtigen. foo + 5, wenn foo ein Zeiger ist, werden 5 Objekte im Speicher weiter vorwärts gehen, egal welche Größe das Objekt foo zeigt (vorausgesetzt, dass foo auf den Typ zeigt, auf den es erklärt wird).

Answer 4

/* reverse: Reverses the string pointed to by `string` */ 
    void reverse(char *string) 
    { 
     int length, c; 
     char *begin, *end, temp; 

     /* compute length of string, initialize pointers */ 
     length = string_length(string); 
     begin = string; /* points to the beginning of string */ 
     end = string; /* will later point to the end of string */ 

     /* make end point to the end */ 
     for (c = 0; c < length - 1; c++) 
     end++; 

     /* walk through half of the string */ 
     for (c = 0; c < length/2; c++) 
     {   
     /* swap the begin and end pointers */ 
     temp = *end; 
     *end = *begin; 
     *begin = temp; 

      /* advance pointers */ 
      begin++; 
      end--; 
     } 
    } 

/* computes length of pointer */ 
int string_length(char *pointer) 
{ 
    int c = 0; 

    /* while we walk `pointer` and we don't see the null terminator */ 
    while(*(pointer + c) != '\0')//I DON'T UNDERSTAND THIS PART!!!!! 
     c++; /* advance position, c */ 

    /* return the length */ 
    return c; 
} 

Die string_length Funktion kann als

size_t strlen(const char *str) 
{ 
    size_t i; 

    for (i = 0; *str; ++i) 
     ; 

    return i; 
} 

Answer 5

hier neu geschrieben werden Sie über Pointer-Arithmetik sprechen kann.

Es ist ein wichtiges Konzept:

• Addition eine ganze Zahl auf einen Zeiger wird vorwärts den Zeiger bewegen. Die Nummer, die Sie hinzufügen, ist multipliziert durch die Größe des Typs, auf den der Zeiger zeigt.

Beispiel:

Ein int auf 4 Bytes codiert, so dass, wenn wir den Zeiger um 1 erhöhen, müssen wir um 4 zu multiplizieren zu bekommen, was wirklich in regelmäßiger Arithmetik passieren.

int a[3] = {1, 3, 6}; 

printf("%d\n", *(a + 1)); // print 3, look 4 bytes ahead 

printf("%d \n", *(a + 2)); //print 6, look 8 bytes ahead 

In Ihrem Fall:

A char codiert ist auf 1 Byte, so

*(pointer + c) with c == 3 

auf eine Speicheradresse von 3 Bytes (3 Zeichen) weiter auswertet.

So ist der Code:

while(*(pointer + c) != '\0') 
    c++; 

wird den Wert Ihres Zeiger an einer bestimmten Speicheradresse bewerten. Wenn das Zeichen gleich null-Zeichen ist, haben wir das Ende der Zeichenfolge erreicht.