Programar em C/Ponteiros: diferenças entre revisões

[edição não verificada][edição não verificada]
Conteúdo apagado Conteúdo adicionado
Edudobay (discussão | contribs)
Edudobay (discussão | contribs)
Sem resumo de edição
Linha 106:
(*p)++;
Aqui, colocamos <code>*p</code> entre parênteses para especificar que queremos alterar o valor apontado por <var>p</var>. Ou seja, aqui iremos incrementar o conteúdo da variável apontada pelo ponteiro p.
 
* *p++
Neste caso, o efeito não é tão claro quanto nos outros exemplos. A ''precedência'' do operador <code>++</code> sobre o operador <code>*</code> faz com que a expressão seja equivalente a <code>*(p++)</code>. O valor atual de ''p'' é retornado ao operador <code>*</code>, e o valor de <code>p</code> é incrementado. Ou seja, obtemos o valor atual do ponteiro e já o fazemos apontar para o próximo valor.
 
x = *(p + 15);
Esta linha atribui a uma variável <var>x</var> o conteúdo do décimo-quinto inteiro adiante daquele apontado por <var>p</var>. Por exemplo, suponhamos que tivéssemos uma série de variáveis <var>i0</var>, <var>i1</var>, <var>i2</var>, &hellip; <var>i15</var> e que <var>p</var> apontasse para <var>i0</var>. Nossa variável <var>x</var> receberia o valor de <var>i15</var>.
 
 
Tente acompanhar este exemplo dos dois tipos de atribuição de ponteiros:
 
int *a, *b, c = 4, d = 2;
a = &c; // '''a''' apontará para '''c'''
b = &d; // '''b''' apontará para '''d'''
*b = 8; \\ // altero o valor existente na variavel “d”'''d'''
*a = *b; // copio o valor de '''d''' (apontado por '''b''')
// para '''c''' (apontado por '''a''')
*a = 1; // altero o valor da variável '''c'''
b = a; // '''b''' aponta para o mesmo lugar que '''a''',
// ou seja, para '''c'''
*b = 0; // altero o valor de '''c'''
 
= Intermediário =
Linha 219 ⟶ 236:
ptr[1];
*(ptr + 1)
 
Repara ainda na seguinte possibilidade: atribuir o valor de um ponteiro a outro (depois de declarados, e iniciado)
tente acompanhar este caso, está bem engraçado!!
int *a, *b, c=4, d=2;
a=&c; \\ atribuo o endereço de “c” á variavel “a”
b=&d; \\ atribuo o endereço de “d” á variavel “b”
*b=8; \\ altero o valor existente na variavel “d”
*a=*b; \\ atribuo o valor existente na variavel apontada por b à variavel apontada por a
*a=1;
b=a; \\ atribuo o valor de a a b, ou seja, passo os endereços
*b=0; \\ atribuo o valor zero á variável que o b aponta.
 
 
Vamos continuar no exemplo anterior, se eu fizer
* a++
o que estamos a fazer é “a=a+1” ou seja vamos pegar no valor existente em a, que é um endereço e acrescentamos uma unidade.
o engraçado é que a unidade de incremento tem a ver com a tipologia de variavel para a qual o ponteiro aponta, por isso se o ponteior estiver a apontar para um int, teremos um incremento de 4 bytes no endereço anteriormente guardado.
* (*p)++
aqui o operador () tem mais precedência por isso estamos a fazer (*p)=(*p)+1
ou seja vamos incrementar em uma unidade o valor existente na variavel apontada pelo ponteiro.
* *p++
aqui o ++ tem maior precedência do que o *, logo estaríamos a fazer *(p=p+1)
por isso iríamos incrementar em 1 unidade o valor existente em p, como é um ponteiro guarda um endereço, e vai incrementar 4 bytes se estiver a apontar para um inteiro. Por fim estamos a ler o valor existente na variável para qual é apontada.
* *(p+5)
conteúdo do ponteiro 5 posições adiante (curto e grosso :)
 
== Comparando endereços ==
Linha 263 ⟶ 255:
i++;
}
system ("pause");
return 0;
}