Programação c: como trabalhar matemática ponteiro em uma matriz

O que acontece quando você incrementa um ponteiro em programação C? Dizer que variável ponteiro dave faz referência a uma variável de 0x8000 endereço de memória. Se assim for, considere a seguinte declaração:

Video: PONTEIROS E MATRIZES | Linguagem C #022

dave ++ -

Qual seria o valor do ponteiro dave ser?

Sua primeira inclinação deve ser a dizer que dave seria incrementado por 1, o que é correto. Mas o resultado do cálculo pode não ser 0x8001. Isso porque o endereço armazenado em uma variável ponteiro é incrementado por um unidade, não por um dígito.

O que é uma unidade?

Depende do tipo de variável. Se ponteiro dave é um ponteiro char, na verdade, o novo endereço poderia ser 0x8001. Mas se dave foram um int ou um float, o novo endereço seria o mesmo que

0x8000 + sizeof (int)

ou

0x8000 + sizeof (flutuador)

Na maioria dos sistemas, um int é de 4 bytes, assim que você poderia adivinhar que dave seria igual a 0x8004 após a operação de incremento. Mas por que acho que quando você pode codificar?

Arrays e Pointer Math ilustra um programa simples, algo que você pode codificar sem usar ponteiros: Preenche um array int com os valores de 1 a 10, e, em seguida, exibir a matriz e os seus valores. Mas, em Arrays e Pointer Math, um ponteiro é usado para preencher a matriz.

Arrays e MATH POINTER

#include int main () {int números [10] -int x-int * pn-pn = numbers- / * inicializar ponteiro * // * Encha matriz * / for (x = 0-xlt; 10-x ++) {* pn = x + 1-pn ++ -} / * matriz de exibição * / for (x = 0-xlt; 10-x ++) printf ("números [% d]% = dn", X + 1, números [x]) - retorno (0) -}

Linha 7 declara o pn ponteiro, e Linha 9 inicializa. o & não é necessária porque os números aqui é uma matriz, não uma variável individual. Nesse ponto, o ponteiro contém o endereço de base da matriz. Tenha em mente que a matriz está vazia.

O circuito para a linhas 12 a 16 preenche a matriz números. O primeiro elemento é preenchido na Linha 14, utilizando a notação Peeker para pn ponteiro. Em seguida, na Linha 15, ponteiro pn é incrementado uma unidade. Verificou-se agora aponta para o elemento seguinte na matriz, e as repetições de ansa.

Exercício 1: Copie o código-fonte do Arrays e Pointer Math em seu editor. Construir e executar.

Exercício 2: Modificar seu código-fonte do Exercício 1 para que o endereço de cada elemento na matriz é exibido juntamente com o seu valor.

Na saída do Exercício 2, você verá que cada endereço é separado por 4 bytes (assumindo que o tamanho de um int é de 4 bytes em sua máquina). Na verdade, os endereços provavelmente todos final nas dígitos hexadecimais 0, 4, 8, e C.

exercício 3: Concluir a conversão de matrizes e Pointer Math, eo que você começou no Exercício 2, por ter o segundo loop for exibir os valores da matriz usando o lado de Peeker do ponteiro variável pn.

Exercício 4: Criar um novo projeto que preenche uma matriz de char usando ponteiros semelhantes aos mostrados na Arrays e Pointer Math. Defina o tamanho da matriz de char a 27 de modo que ele pode conter 26 letras. Encher a matriz com as letras ‘A’ através de ‘Z’, usando a notação ponteiro. Exibir os resultados usando a notação ponteiro.

Aqui está uma grande dica:

* Pn = x + `A`-

SOLUÇÃO PARA EXERCÍCIO 4

#include int main () {char alfabeto [27] -int x-char * aa-aa = alphabet- / * inicializar ponteiro * // * Encha matriz * / for (x = 0-xlt; 26-x ++) {* aa = x + `A`-PA ++ -} aa = alfabeto - / * matriz de exibição * / for (x = 0-xlt; 26-x ++) {putchar (* aa) -pa ++ -} putchar (` n ") - retorno (0) -}

O código-fonte na solução do Exercício 4should ser bastante lúcido, realização de cada tarefa um passo de cada vez. Mas tenha em mente que muitos programadores C gostam de combinar declarações, e tais combinações acontecem com freqüência com ponteiros.

Exercício 5: Combine as duas declarações no primeiro loop da solução do Exercício 4to ser apenas uma instrução:

* Aa ++ = x + `A`-

Certifique-se de digitá-lo corretamente. Construir e executar.

A saída é o mesmo. O que essa bagunça feia faz é descrito aqui:

x +’A`This parte da declaração é executada primeiro, adicionando o valor da variável x à carta A. O efeito líquido é que o código marcha até o alfabeto como o valor de x aumenta.

* Resultado pathe de x +’A’ é colocado dentro da localização de memória especificado por ponteiro pa.

++O valor do pa variável - o endereço de memória - é incrementado uma unidade. Porque a ++ aparece depois da variável, o valor é incrementado depois de o valor nesse endereço é lido.

Video: Vetores e Matrizes em C - Aula 13 - Algoritmos e Programação 2012.1

Manter as duas declarações separadas ainda funciona. Mas nem todo programador faz isso! Muitos deles gostam de empilhar ponteiros com o operador de incremento. Cuidado com ele! Ou, se você entendê-lo, usá-lo.

Exercício 6: Repare o seu código-fonte do Exercício 5 para que o segundo loop for usa o monstro * pa ++.

Felizmente, o * pa ++ ponteiro-coisa faz sentido. Se não, tirar uma soneca e depois voltar e examinar Head-Imploding Programa.

HPROGRAMA EAD-implodir

#include int main () {char alfa = `A`-X-int char * aa-aa = &alfa- / * inicializar ponteiro * / for (x = 0-xlt; 26-x ++) putchar ((* aa) ++) - putchar ( `n`) - retorno (0) -}

O código de fonte a partir da Listagem 19-4 promoções com uma variável de char único e não uma matriz. Portanto, a inicialização ponteiro em Linha 9 requer a & prefixo. Não se esqueça disso!

Linha 12 neste código contém o booger (* aa) ++. É parecido com * pa ++, mas definitivamente não é. Ao contrário aa * ++, que espia um valor e, em seguida, incrementa o ponteiro, o (* aa) ++ construção incrementa um valor sendo peeked no- o ponteiro é inalterada.

exercício 7: Editar, criar e executar um novo programa usando o código-fonte de Head-Imploding Programa.

A operação (* aa) ++ funciona, graças aos parênteses. O programa recupera o valor representado por * pa primeiro e depois esse valor é incrementado. A variável de ponteiro, pn, não é afetada pela operação.

Para ajudar a evitar a confusão sobre este tema aqui são as várias bugigangas notação enigmática ponteiro / Peeker: