Tiefe Kopie eines Arrays von ganzen Zahlen, nur mit Zeigerarithmetik

Question

Ich muss eine Funktion schreiben, die eine tiefe Kopie eines Arrays von Ganzzahlen macht, mit nur Zeigerarithmetik (dh kann Array-Element-Syntax wie orig [i] nicht verwenden).

Das erste Argument ist das Array zu kopieren, und seine Länge wird durch das zweite Argument angegeben. Hier

ist das, was ich bisher:

int* copyArray(const int *orig, int size) { 

    int *copy = malloc(size * sizeof *copy); 

    int **toReturn = © 

    for (int i = 0; i < size; i++, orig++, copy++) { 
    *copy = *orig; 
    } 

    return *toReturn; 

} 

int main() { 

    int testArray[3] = {1, 2, 3}; 
    int *testptr = testArray; 

    int *copied = copyArray(testptr, 3); 

    for (int i = 0; i < 3; i++) { 

    printf("%d %p", testArray[i], &testArray[i]); 
    printf("\n"); 

    } 

    printf("\n"); 

    for (int i = 0; i < 3; i++) { 

    printf("%d %p", copied[i], &copied[i]); 
    printf("\n"); 

    } 

return 0; 
} 

Dies ist nicht mir, die richtigen Ergebnisse zu erzielen ... Das Ergebnis, das ich von diesem erhalten ist:

1 0x7ffce0ff6fd0 
2 0x7ffce0ff6fd4 
3 0x7ffce0ff6fd8 

0 0xe1301c 
0 0xe13020 
0 0xe13024 

während es sein sollte sein:

1 0x7ffce0ff6fd0 
2 0x7ffce0ff6fd4 
3 0x7ffce0ff6fd8 

1 0xe1301c 
2 0xe13020 
3 0xe13024 

ich auf Zeiger und Speicherzuweisung bin neu ... Was mache ich falsch?

UPDATE: Problem behoben!

Schauen Sie sich meine Antwort an, oder die anderen Antworten, die auch funktionieren.

Answer 1

ändern copyArray zu so etwas wie

int *copyArray(const int *orig, size_t size) 
{ 
    int *copy = malloc(size * sizeof(*copy)); 

    for (size_t ii = 0; ii < size; ii++) 
    { 
     copy[ ii ] = orig[ ii ]; 
    } 
    return(copy); 
} 

Stilistisch Ich mag persönlich ii statt i. Es ist schwer nach i zu suchen. Und size_t ist eine bessere Wahl als int für etwas, das verwendet wird, um die Größe von etwas zu beschreiben.

Sie sollten wahrscheinlich einige Fehlerprüfung hinzufügen, sollte mallocNULL zurückgeben.

Und ohne den Zeiger Indizierung (weil einfacher Code ist verboten werden?!?)

int *copyArray(const int *orig, size_t size) 
{ 
    int *copy = malloc(size * sizeof(*copy)); 

    memcpy(copy, orig, size * sizeof(*copy)); 
    return(copy); 
} 

ohnehin wahrscheinlich schneller ist. Die richtige Header-Einfügung bleibt als eine Größe für den Leser übrig ... ;-)

Es muss jedoch noch eine Fehlerüberprüfung durchgeführt werden.

Answer 2

Dies ist eine Arbeitsversion der Copyarray-Funktion:

int* copyArray(const int *orig, int size) { 

    int *copy = malloc(size * sizeof *copy); 

    int *toReturn = copy; 

    for (int i = 0; i < size; i++, orig++, copy++) { 
    *copy = *orig; 
    } 

    return toReturn; 

}