Ich konnte nicht verstehen, was tut dieses Programm tut, ist es eine rekursive ein

Question

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

#define SIZE 10 

int whatIsThis(const int b[], size_t p); 

int main(void) { 
    int x; 
    int a[SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 

    x = whatIsThis(a, SIZE); 

    printf("result is %d\n", x); 

    _sleep(1000 * 100); 
} 

int whatIsThis(const int b[], size_t p) { 
    if (1 == p) { 
     return b[0]; 
    } else { 
     return b[p - 1] + whatIsThis(b, p - 1); 
    } 
} 

Leider ist diese Frage zu stellen, aber ich bin fast Anfänger in C-Programmierung und ich konnte die Logik dieses Programms nicht verstehen, vor allem return b[p-1]+ whatIsThis(b,p-1);. Was ist die Logik davon?

Answer 1

Was ist das?

Es ist eine Funktion mit undefiniertem Verhalten. :)

Wenn das zweite Argument 0 versucht, die Funktion gleich p - 1 Speicher in der Position für den Zugriff auf den im allgemeinen als Typ unsigned size_t ein Typ ist, konvertiert auf den Maximalwert, der in einem Objekt vom Typ size_t gespeichert werden kann.

Außerdem wird innerhalb der Funktion die Additionsoperation verwendet, dann kann es einen Überlauf für zwei große Zahlen geben. Daher sollte der Rückgabetyp der Funktion ein anderer größerer ganzzahliger Typ sein.

Also lassen Sie uns die Funktion umschreiben, die diese Nachteile zu beseitigen. Die Logik wird dieselbe sein.

long long int whatIsThis(const int a[], size_t n) 
{ 
    return n == 0 ? 0 : a[n-1] + whatIsThis(a, n - 1); 
} 

oder ohne ternären mit (bedingt) Operator die Funktion

long long int whatIsThis(const int a[], size_t n) 
{ 
    if (n == 0) 
    { 
     return 0; 
    } 
    else 
    { 
     return a[n-1] + whatIsThis(a, n - 1); 
    } 
} 

wie

aussehen

Nun lassen Sie-s prüfen, wie die Funktion arbeitet. Wenn Sie ein Array wie diese haben

int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 

Sie können es die folgende Art und Weise vorstellen (obwohl dieser Code nicht kompiliert werden)

int a[10] = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10 }; 

oder ähnliche

int a[10] = { a1[9], 10 }; 

wobei a1 [ 9] ist eine Anordnung von 9 Elementen

int a1[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 

wiederum das Array a1 kann wie

int a1[9] = { a2[8], 9 }; 

vorstellen

wo a2

ist

int a2[8] = { 1, 2, 3, 4, 5, 6, 7, 8 }; 

und so weiter, dass wir endlich

int a8[2] = { a9[1], 2 }; 

bekommen, wo a9

int a9[1] = { 1 }; 

ist

Was macht die Funktion?

für das Array a die wie

int a[10] = { { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 10 }; 

oder dergleichen

int a[10] = { a1[9], 10 }; 

die Funktion fügt a1[9] + 10

wiederum für das Array vorgestellt wurde a1 die wie

vorstellt 0

oder wie

int a1[9] = { a2[8], 9 }; 

die Funktion a2[8] + 9

Wenn berechnet a1[9] im Ausdruck a1[9] + 10 mit a2[8] + 9 zu ersetzen, dann werden wir a2[8] + 9 + 10 bekommen und so weiter.

Also die Funktion berechnet die Summe der Elemente des Arrays.

Answer 2

Die Funktion berechnet die Summe der Elemente im Array rekursiv.

Wenn die Funktion das erste Mal aufgerufen wird p = 10. Der Teil return b[p-1]+ whatIsThis(b,p-1) wird b[9] nehmen und die Funktion mit whatIsThis(b,9) aufrufen, die return b[8]+ whatIsThis(b,8) ... den ganzen Weg bis return b[1]+ whatIsThis(b,1) zurückgibt, der b[0] zurückgibt.

Answer 3

Um den Code zu verstehen, müssen Sie ihn sorgfältig lesen. Der Code wurde schlecht präsentiert, was es selbst für versierte Programmierer schwer zu lesen macht. Platzieren Sie das Programm so, wie ich es in meinem Schnitt gemacht habe.

Die Funktion whatIsThis() erste Tests, wenn sein zweites Argument p den Wert 1, mit einem dummen invertierten Syntax (1 == p) in einem lame Versuch hat ein potentiell vertippt == Bediener zu erkennen: 1 = p ein Syntaxfehler wäre, während p = 1 syntaktisch korrekt wären, aber kein Test auf . Der Name des zweiten Arguments ist irreführend, es ist die Anzahl der Elemente in b Als solches wäre es besser, es n, len, count ... zu nennen, aber nicht p, das klassisch für Zeiger verwendet wird.

Wenn diese Größe 1 ist, gibt die Funktion den Wert des ersten Elements des Arrays zurück.

Wenn nicht, gibt es die Summe des letzten Elements und das Ergebnis eines Aufrufs an sich selbst für dasselbe Array und ein Element weniger zurück.

Daher berechnet die Funktion die Summe der Elemente des Arrays.

Beachten Sie, dass diese Funktion Humbug ist: es einen 0 Wert für p nicht umgehen kann und nicht definiertes Verhalten aufruft. Eine einfachere und sicherere Version wäre:

int whatIsThis(const int b[], size_t n) { 
    if (n == 0) { 
     return 0; 
    } else { 
     return b[n - 1] + whatIsThis(b, n - 1); 
    } 
} 

Oder alternativ:

int whatIsThis(const int b[], size_t n) { 
    if (n == 0) { 
     return 0; 
    } else { 
     return b[0] + whatIsThis(b + 1, n - 1); 
    } 
} 

Natürlich eine rekursive Ansatz für eine solche einfache Aufgabe ist riskant, da es sehr tief in den Stapel Rekursion kann und nicht definiertes Verhalten aufrufen für mäßig große Arrays. Der Compiler kann die Rekursion nicht immer optimieren, insbesondere wenn es sich nicht um eine Tail-Rekursion handelt, und dies ist normalerweise nicht der Fall.