use - vector of pointers in c




Diferença entre*ptr+= 1 e*ptr++ em C (4)

Eu comecei a estudar C, e ao fazer um exemplo sobre passar ponteiro para ponteiro como parâmetro de uma função, encontrei um problema.

Este é o meu código de amostra:

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

O problema ocorre na linha 16, quando modifico *ptr+=1 para *ptr++ . O resultado esperado deve ser o array inteiro e o número 1, mas quando eu uso *ptr++ o resultado é 0.

Existe algum diffirence entre +=1 e ++ ? Eu pensei que os dois são iguais.


* ptr + = 1: Incremento de dados para os quais ptr aponta. * ptr ++: Incrementar o ponteiro que aponta para o próximo local de memória em vez dos dados para os quais o ponteiro aponta.


A diferença é devida à precedência do operador.

O operador pós-incremento ++ tem precedência mais alta que o operador de remoção de referência * . Então *ptr++ é equivalente a *(ptr++) . Em outras palavras, o incremento de postagem modifica o ponteiro, não o que ele aponta.

O operador de atribuição += tem precedência menor do que o operador de remoção de referência * , portanto, *ptr+=1 é equivalente a (*ptr)+=1 . Em outras palavras, o operador de atribuição modifica o valor para o qual o ponteiro aponta e não altera o próprio ponteiro.


Muito boa pergunta.

Em K & R "linguagem de programação C" "5.1 Ponteiros e endereços", podemos obter uma resposta para isso.

"Os operadores unários * e & ligam-se mais fortemente que os operadores aritméticos"

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

"Operadores unários como * e ++ associam da direita para a esquerda ."

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

// Funciona como * (ptr ++).

A maneira correta é:

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

Vamos aplicar parênteses para mostrar a page

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

Vamos fazer de novo com

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

E novamente com

*ptr++
*(ptr++)
  • Em *ptr += 1 , incrementamos o valor da variável para a qual nosso ponteiro aponta .
  • Em *ptr++ , incrementamos o ponteiro depois que nossa declaração inteira (linha de código) é feita e retornamos uma referência para a variável para a qual nosso ponteiro aponta .

O último permite que você faça coisas como:

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++);
}

Este é um método comum usado para copiar um array src em outro array de dest .





post-increment