Wyrażenia wskaźnikowe: * ptr++, * ++ptr i ++ * ptr

Załóżmy, że ptr wskazuje na i-ten element tablicy arr.

1. *ptr++ ocenia do arr[i] i ustawia ptr, aby wskazać (i+1)-Ten element arr. Jest odpowiednikiem *(ptr++).

2. *++ptr ustawia ptr, aby wskazać (i+1)-Ten element arr i ewaluuje do arr[i+1]. Jest odpowiednikiem *(++ptr).

3. ++*ptr zwiększa arr[i] o jeden i ocenia do jego zwiększonej wartości; wskaźnik {[0] } pozostaje nietknięty. Jest to równoważne ++(*ptr).

Jest jeszcze jeden, ale trzeba by nawiasy napisać:

1. (*ptr)++ zwiększa arr[i] o jeden i ocenia do jego wartości przed zwiększeniem; wskaźnik ptr pozostaje ponownie nietknięty.

Resztę możesz sam wymyślić; na to też odpowiedział @Jaguar.

*ptr++ : post increment a pointer ptr

*++ptr : Pre Increment a pointer ptr

++*ptr : preincrement the value at ptr location

Przeczytaj tutaj o operatorach Pre increment i post increment

To da Hello jako wyjście

int main()
{
    const char *p = "Hello";
    while(*p)
         printf("%c",*p++);//Increment the pointer here 
    return 0;
}

Stan w Twojej pętli jest zły:

while(*p++)
    printf("%c",*p);

Jest tym samym co

while(*p)
{
    p++;
    printf("%c",*p);
}

I to jest złe, to powinno być:

while(*p)
{
    printf("%c",*p);
    p++;
} 

*ptr++ jest tym samym co *(ptr++), czyli:

const char  *ptr = "example";
char  value;

value = *ptr;
++ptr;
printf("%c", value); // will print 'e'

*++ptr jest tym samym co *(++ptr), czyli:

const char  *ptr = "example";
char  value;

++ptr;
value = *ptr;
printf("%c", value); // will print 'x'

++*ptr jest tym samym co ++(*ptr), czyli:

const char  *ptr = "example";
char  value;

value = *ptr;
++value;
printf("%c", value); // will print 'f' ('e' + 1)

Masz rację co do pierwszeństwa, zauważ, że {[0] } ma pierwszeństwo przed przyrostkiem, ale nie przed przyrostkiem postfixa. Oto jak te załamania:

*ptr++ - idąc od lewej do prawej, dereferencja wskaźnika, a następnie zwiększenie wartości wskaźnika (nie to, co wskazuje, ze względu na pierwszeństwo postfixa nad dereferencją)

*++ptr - zwiększ wskaźnik, a następnie dereferencję, dzieje się tak dlatego, że prefix i dereferencja mają ten sam priorytet i dlatego są oceniane w kolejność od prawej do lewej

++*ptr - podobnie jak powyżej w zakresie pierwszeństwa, ponownie przechodząc od prawej do lewej w celu dereferencji wskaźnik, a następnie zwiększyć to, co wskazuje wskaźnik. Zwróć uwagę, że w Twoim przypadku będzie to prowadzić do niezdefiniowanego zachowania, ponieważ próbujesz zmodyfikować zmienną tylko do odczytu (char* p = "Hello";).

Dodam moje zdanie, ponieważ o ile inne odpowiedzi są poprawne, to myślę, że czegoś im brakuje.

 v = *ptr++

Oznacza

 temp = ptr;
 ptr  = ptr + 1
 v    = *temp;

Gdzie jako

 *++ptr

Oznacza

 ptr = ptr + 1
 v   = *ptr

 temp = ptr       // Temp created here!!!
 ptr  = ptr + 1   // or - 1 if decrement)
 v    = *temp     // Temp destroyed here!!!

Dlaczego to ma znaczenie? W C to nie jest takie ważne. W C++ choć ptr może być typem złożonym jak iterator. Na przykład

 for (std::set<int>::iterator it = someSet.begin(); it != someSet.end(); it++)

W tym przypadku, ponieważ it jest złożonym typ it++ może mieć skutki uboczne ze względu na tworzenie temp. Oczywiście, jeśli masz szczęście, kompilator spróbuje wyrzucić kod, który nie jest potrzebny, ale jeśli konstruktor lub Destruktor iteratora coś zrobi, to it++ pokaże te efekty podczas tworzenia temp.

Krótki z tego co próbuję powiedzieć to napisz co masz na myśli . Jeśli masz na myśli przyrost ptr to napisz ++ptr a nie ptr++. Jeśli masz na myśli temp = ptr, ptr += 1, temp to napisz ptr++

Postfix i prefiks mają wyższy priorytet niż dereferencja, więc

*ptr++ tutaj post increment ptr a następnie wskazanie nowej wartości ptr

* ++ptr tutaj Pre inkrementuj pięść, a następnie wskaż nową wartość ptr

++ * ptr tutaj najpierw uzyskaj wartość ptr wskazującą i zwiększającą, że vlaue

*ptr++    // 1

To jest to samo co:

    tmp = *ptr;
    ptr++;

Tak więc wartość obiektu wskazywanego przez ptr jest pobierana, a następnie ptr jest zwiększana.

*++ptr    // 2

To jest to samo co:

    ++ptr;
    tmp = *ptr;

Zatem wskaźnik ptr jest zwiększany, a następnie odczytywany jest obiekt wskazywany przez ptr.

++*ptr    // 3

To jest to samo co:

    ++(*ptr);

Tak więc obiekt wskazywany przez ptr jest zwiększany; ptr sam w sobie pozostaje niezmieniony.

Wyrażenia wskaźnikowe: * ptr++, * ++ptr i ++ * ptr:

Notatka: wskaźniki muszą być zainicjalizowane i muszą mieć poprawny adres. Ponieważ w pamięci RAM oprócz naszego programu (a. out) jest o wiele więcej programów działających jednocześnie tj. jeśli próbujesz uzyskać dostęp do pamięci, która nie była zarezerwowana dla Ciebie System operacyjny będzie przez segmentację usterki.

Zanim to wyjaśnimy rozważmy prosty przykład ?

#include<stdio.h>
int main()
{
        int num = 300;
        int *ptr;//uninitialized pointer.. must be initialized
        ptr = &num;
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr = *ptr + 1;//*ptr means value/data on the address.. so here value gets incremented
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        /** observe here that "num" got changed but manually we didn't change, it got modified by pointer **/
        ptr = ptr + 1;//ptr means address.. so here address got incremented
        /**     char pointer gets incremented by 1 bytes
          Integer pointer gets incremented by 4 bytes
         **/
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

Analizuj wyjście powyższego kodu, mam nadzieję, że masz wyjście powyższego kodu. Z powyższego kodu wynika jedno, że nazwa wskaźnika (ptr ) oznacza, że mówimy o adresie i * ptr oznacza, że mówimy o abbout value /data.

CASE 1 : *ptr++, * ++ptr, * (ptr++) i * (++ptr) :

Wyżej wymienione wszystkie 4 składnie są podobne, we wszystkich address gets incremented ale jak adres jest zwiększany, to jest inaczej.

Uwaga : do rozwiązywania dowolnych wyrażeń dowiedz się jak wiele operatorów znajduje się w wyrażeniu, a następnie dowiadujemy się o priorytetach operatora. I wiele operatorów o tym samym priorytecie, a następnie sprawdzić kolejność ewolucji lub Asocjacja, które mogą od prawej (R) do lewej (L) ot od lewej do prawej.

*ptr++: tutaj są dwa operatory, mianowicie de-reference ( * ) i ++(increment). Oba mają ten sam priorytet, a następnie sprawdź asocjację, która jest od R do L. więc zaczyna rozwiązywać od prawej do lewej, niezależnie od operatorów nadchodzi pierwszy.

*ptr++: pierwszy ++ przyszedł podczas rozwiązywania z R do L, więc adres jest zwiększany, ale jego przyrost post.

*++ptr: tak samo jak pierwszy tutaj również adres jest inkrementowany, ale jego przed inkrementem.

*(ptr++) : tutaj są 3 operatory, wśród nich grouping () o najwyższym priorytecie, więc pierwszy PTR++ rozwiązany tzn. adres zostanie zwiększony, ale post.

*(++ptr) : tak samo jak powyzszy przypadek tutaj tez adres dostaje incremented ale Pre increment.

CASE 2 : ++*ptr, ++(*ptr), (*ptr)++ :

Wyżej wymienione wszystkie 4 składnie są podobne, w wszystkie wartości / dane są zwiększane ale jak zmienia się wartość, to jest inaczej.

++*ptr : pierwsze * przyszło podczas rozwiązywania z R do L, więc wartość jest zmieniana, ale jej przedrostek.

++(*ptr) : tak samo jak powyżej, wartość jest modyfikowana.

(*ptr)++: tutaj są 3 operatory, wśród nich grouping () o najwyższym priorytecie, wewnątrz () * ptr jest tam, więc pierwszy * ptr jest rozwiązany, tzn. wartość jest zwiększana, ale post.

Uwaga : ++ * ptr i *ptr = * ptr + 1 są takie same, w obu przypadkach wartość jest zmieniana. ++ * ptr: używana jest tylko 1 Instrukcja (INC), bezpośrednio wartość jest zmieniana w jednym strzale. * ptr = * ptr + 1: tutaj pierwsza wartość zostanie zwiększona (INC), a następnie przypisana (MOV).

Aby zrozumieć wszystkie powyższe różne składnie przyrost na wskaźniku pozwala rozważyć prosty kod:

#include<stdio.h>
int main()
{
        int num = 300;
        int *ptr;
        ptr = &num;
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//address changed(post increment), value remains un-changed
//      *++ptr;//address changed(post increment), value remains un-changed
//      *(ptr)++;//address changed(post increment), value remains un-changed
//      *(++ptr);//address changed(post increment), value remains un-changed

//      ++*ptr;//value changed(pre increment), address remains un-changed
//      (*ptr)++;//value changed(pre increment), address remains un-changed
//      ++(*ptr);//value changed(post increment), address remains un-changed

        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

W powyższym kodzie spróbuj komentować / komentować komentarze i analizować wyniki.

Wskaźniki jako stałe : nie ma sposobów, za pomocą których można zrobić wskaźniki jako stałe, kilka wspominam tutaj.

1)const int * P lub int const * p : tutaj value jest stałą, adres nie jest stały czyli gdzie p wskazuje ? Jakiś adres ? Pod tym adresem jaka jest wartość ? Jakaś wartość, PRAWDA ? Wartość ta jest stała, nie można zmodyfikować tej wartości, ale gdzie wskaźnik jest wskazywany ? Jakiś adres, prawda ? Może również wskazywać na inny adres.

Aby to zrozumieć rozważmy poniższy kod:

#include<stdio.h>
int main()
{
        int num = 300;
        const int *ptr;//constant value, address is modifible
        ptr = &num;
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//
//      *++ptr;//possible bcz you are trying to change address which is possible
//      *(ptr)++;//possible
//      *(++ptr);//possible

//      ++*ptr;//not possible bcz you trying to change value which is not allowed
//      (*ptr)++;//not possible
//      ++(*ptr);//not possible

        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

Spróbuj przeanalizować wyjście powyższego kodu

2)int const * p: nazywa się "**constant pointe**r " tzn. address is constant but value is not constant. Tutaj nie możesz zmienić adresu, ale możesz zmodyfikować wartość.

Uwaga : stały wskaźnik (powyżej) musi initialize while declaration itself.

Aby to zrozumieć, sprawdźmy prosty kod.

#include<stdio.h>
int main()
{
        int x = 300;
        int* const p;
        p = &x;
        printf("x = %d p =%p and *p = %d\n",num,p,*p);
}

W powyższym kodzie, jeśli zauważysz, że nie ma ++ * p lub * P++, więc możesz pomyśleć, że jest to prosty przypadek, ponieważ nie zmieniamy adresu ani wartości, ale spowoduje to błąd. Dlaczego ? Powód, o którym wspominam w komentarzach.

#include<stdio.h>
int main()
{
        int x = 300;
        /** constant pointer must initialize while decaring itself **/
        int* const p;//constant pointer i.e its pointing to some address(here its pointing to garbage), it should point to same address(i.e garbage ad
dress only 
        p = &x;// but here what we are doing ? we are changing address. we are making p to point to address of x instead of garbage address.
        printf("x = %d p =%p and *p = %d\n",num,p,*p);
}

Więc jakie jest rozwiązanie tego problemu ?

     int* const p = &x;

Aby dowiedzieć się więcej o tym przypadku, rozważmy poniższy przykład.

#include<stdio.h>
int main()
{
        int num = 300;
        int *const ptr = &num;//constant value, address is modifible
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//not possible
//      *++ptr;//not possible bcz you are trying to change address which is not possible
//      *(ptr)++;//not possible
//      *(++ptr);//not possible

//      ++*ptr;// possible bcz you trying to change value which is allowed
//      (*ptr)++;// possible
//      ++(*ptr);// possible
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

3)const int * const p : tutaj zarówno adres, jak i wartość są stałymi.

Aby to zrozumieć, sprawdźmy poniższy kod

#include<stdio.h>
int main()
{
        int num = 300;
        const int* const ptr = &num;//constant value,constant address 
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//not possible
        ++*ptr;//not possible
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

const char *p = "Hello";   

*p means "Hello"
          ^
          | 
          p

*p++ means "Hello"
             ^
             | 
             p

*++p means "Hello"
            ^
            |     (WHILE THE STATEMENT IS EXECUTED)
            p

*++p means "Hello"
             ^
             |     (AFTER THE STATEMENT IS EXECUTED)
             p

++*p oznacza, że próbujesz zwiększyć wartość ASCII *p, która

   is "Hello"
       ^
       | 
       p

Nie możesz zwiększyć wartości, ponieważ jest to stała, więc otrzymasz błąd

Jeśli chodzi o pętlę while, pętla biegnie aż *p++ dotrze do końca łańcucha, gdzie znajduje się znak '\0' (NULL).

Teraz, ponieważ *p++ pomija pierwszy znak, można uzyskać tylko wyjście począwszy od drugiego znaku.

Poniższy kod nie będzie wyświetlany wszystko ponieważ pętla while ma '\0'

const char *p = "Hello";
    while('\0') 
         printf("%c",*p);

Poniższy kod daje taki sam wynik jak następny kod, czyli ello .

const char *p = "Hello";
    while(*++p)
         printf("%c",*p);

...................................

const char *p = "Hello";
    while(*p++)
         printf("%c",*p);