Różnica między * ptr + = 1 i * ptr ++ w C

Właśnie zacząłem uczyć się C i kiedy robiłem jeden przykład dotyczący przekazywania wskaźnika do wskaźnika jako parametru funkcji, znalazłem problem.

Oto mój przykładowy kod:

#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;
}

Problem pojawia się w linii 16, kiedy modyfikuję *ptr+=1do *ptr++. Oczekiwanym wynikiem powinna być cała tablica i liczba 1, ale kiedy używam *ptr++wyniku, to 0.

Czy jest jakaś różnica między +=1a ++? Myślałem, że obaj są tacy sami.

Różnica wynika z pierwszeństwa operatorów.

Operator post-inkrementacji ++ma wyższy priorytet niż operator wyłuskiwania *. Więc *ptr++jest równoważne *(ptr++). Innymi słowy, przyrost postu modyfikuje wskaźnik, a nie to, na co wskazuje.

Operator przypisania +=ma niższy priorytet niż operator wyłuskiwania *, więc *ptr+=1jest równoważny (*ptr)+=1. Innymi słowy, operator przypisania modyfikuje wartość wskazywaną przez wskaźnik i nie zmienia samego wskaźnika.

Kolejność pierwszeństwa dla 3 operatorów, których dotyczy Twoje pytanie, jest następująca:

post-inkrementacja ++> dereference *> przypisanie+=

Możesz sprawdzić tę stronę, aby uzyskać więcej informacji na ten temat.

Podczas analizowania wyrażenia operator, który jest wymieniony w jakimś wierszu, będzie ściślej powiązany (jak w nawiasach) z jego argumentami niż jakikolwiek operator wymieniony w wierszu dalej pod nim. Na przykład wyrażenie *p++jest analizowane jako *(p++), a nie jako (*p)++.

Krótko mówiąc, aby wyrazić to przypisanie *ptr+=1za pomocą operatora post-inkrementacji, musisz dodać nawiasy do operatora wyłuskiwania, aby nadać tej operacji pierwszeństwo przed ++jak w tym(*ptr)++

Zastosujmy nawiasy, aby pokazać kolejność operacji

a + b / c
a + (b/c)

Zróbmy to jeszcze raz

*ptr   += 1
(*ptr) += 1

I znowu z

*ptr++
*(ptr++)

• W programie *ptr += 1zwiększamy wartość zmiennej, na którą wskazuje nasz wskaźnik .
• W programie *ptr++zwiększamy wskaźnik po wykonaniu całej instrukcji (linii kodu) i zwracamy odniesienie do zmiennej, na którą wskazuje nasz wskaźnik .

Ta ostatnia pozwala na:

for(int i = 0; i < length; i++)
{
    // Copy value from *src and store it in *dest
    *dest++ = *src++;

    // Keep in mind that the above is equivalent to
    *(dest++) = *(src++);
}

Jest to typowa metoda kopiowania srctablicy do innej desttablicy.

Bardzo dobre pytanie.

W K&R „języku programowania C” „5.1 Wskaźniki i adresy” możemy uzyskać odpowiedź na to pytanie.

„Operatory jednoargumentowe * i & wiążą ściślej niż operatory arytmetyczne”

*ptr += 1      //Increment what ptr points to.

„Operatory jednoargumentowe, takie jak * i ++, kojarzą się od prawej do lewej ”.

*ptr++        //Increment prt instead of what ptr point to.

// Działa jak * (ptr ++).

Prawidłowy sposób to:

(*ptr)++      //This will work.

* ptr + = 1: przyrost danych, na które wskazuje ptr. * ptr ++: Wskaźnik przyrostowy, który wskazuje następną lokalizację w pamięci zamiast danych, na które wskazuje wskaźnik.