Ich habe gerade angefangen, C zu studieren, und als ich ein Beispiel für die Übergabe eines Zeigers an einen Zeiger als Funktionsparameter machte, fand ich ein Problem.
Dies ist mein Beispielcode:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int* allocateIntArray(int* ptr, int size){
if (ptr != NULL){
for (int i = 0; i < size; i++){
ptr[i] = i;
}
}
return ptr;
}
void increasePointer(int** ptr){
if (ptr != NULL){
*ptr += 1; /* <----------------------------- This is line 16 */
}
}
int main()
{
int* p1 = (int*)malloc(sizeof(int)* 10);
allocateIntArray(p1, 10);
for (int i = 0; i < 10; i++){
printf("%d\n", p1[i]);
}
increasePointer(&p1);
printf("%d\n", *p1);
p1--;
free(p1);
fgets(string, sizeof(string), stdin);
return 0;
}
Das Problem tritt in Zeile 16, wenn ich ändern *ptr+=1
zu *ptr++
. Das erwartete Ergebnis sollte das gesamte Array und die Nummer 1 sein, aber wenn ich *ptr++
das Ergebnis verwende, ist es 0.
Gibt es einen Unterschied zwischen +=1
und ++
? Ich dachte, dass beide gleich sind.
c
pointers
post-increment
huy nguyen
quelle
quelle
string
.allocateIntArray
ist ein schlechter Name, da es scheint, dass Siemalloc
das Array von der Funktion, aber Sie nicht. Ich schlagefillIntArray
stattdessen vor. 2) Sie verwenden nicht den Rückgabewert vonallocateIntArray
. Ich schlage vor, Sie ändern den Rückgabetyp invoid
. 3) Sollte nichtif (ptr != NULL)
in FunktionincreasePointer
seinif (*ptr != NULL)
? 4) Dasmalloc
Eingießen ist nicht erforderlich. Siehe Souravs Kommentar oben. 5) Dies:for (int i = 0; i < 10; i++){ printf("%d\n", p1[i]); }
undprintf("%d\n", *p1); p1--;
muss beigefügt werdenif(p1 != NULL)
. 6)string.h
wird nicht verwendet.p+=1
ist wie++p
, nicht wiep++
Antworten:
Der Unterschied ist auf die Priorität des Bedieners zurückzuführen.
Der Post-Inkrement-Operator
++
hat eine höhere Priorität als der Dereferenzierungsoperator*
. Ist*ptr++
also gleichbedeutend mit*(ptr++)
. Mit anderen Worten, das Post-Inkrement ändert den Zeiger und nicht das, worauf er zeigt.Der Zuweisungsoperator
+=
hat eine niedrigere Priorität als der Dereferenzierungsoperator*
und*ptr+=1
entspricht daher(*ptr)+=1
. Mit anderen Worten, der Zuweisungsoperator ändert den Wert, auf den der Zeiger zeigt, und ändert den Zeiger selbst nicht.quelle
*p++
und*++p
. Der Operator hat Vorrang vor letzterem, der erstere folgt.Die Rangfolge für die 3 an Ihrer Frage beteiligten Operatoren lautet wie folgt:
Post-Inkrement
++
> Dereferenzierung*
> Zuweisung+=
Sie können diese Seite für weitere Details zu diesem Thema überprüfen .
Um es kurz auszudrücken: Um diese Zuweisung
*ptr+=1
mit dem Post-Inkrement-Operator auszudrücken , müssen Sie dem Dereferenzierungsoperator Klammern hinzufügen, damit diese Operation Vorrang hat++
dieser hat(*ptr)++
quelle
Wenden wir Klammern an, um die Reihenfolge der Operationen anzuzeigen
Lass es uns nochmal machen mit
Und wieder mit
*ptr += 1
erhöhen wir den Wert der Variablen, auf die unser Zeiger zeigt .*ptr++
erhöhen wir den Zeiger, nachdem unsere gesamte Anweisung (Codezeile) ausgeführt wurde, und geben einen Verweis auf die Variable zurück, auf die unser Zeiger zeigt .Letzteres ermöglicht es Ihnen, Dinge zu tun wie:
Dies ist eine gängige Methode zum Kopieren eines
src
Arrays in ein anderesdest
Array.quelle
Sehr gute Frage.
In der Programmiersprache "C" von K & R "5.1 Zeiger und Adressen" können wir eine Antwort darauf erhalten.
"Die unären Operatoren * und & binden enger als arithmetische Operatoren"
"Unäre Operatoren wie * und ++ assoziieren von rechts nach links ."
// Es funktioniert wie * (ptr ++).
Der richtige Weg ist:
quelle
* ptr + = 1: Inkrementiere Daten, auf die ptr zeigt. * ptr ++: Inkrementiert den Zeiger, der auf den nächsten Speicherort zeigt, anstelle der Daten, auf die der Zeiger zeigt.
quelle