Olá, seja bem-vindo de volta.
Como a aritmética de pontos é um conceito meio difícil de entender
e entender, eu queria passar por um
último exemplo que realmente demonstra esse conceito, faz um bom trabalho.
E se você entender este exemplo, não terá
problemas com a aritmética de pontos.
Portanto, o primeiro exemplo que desejo mostrar a você é
o efeito de adicionar um valor inteiro a um ponteiro.
Então, quando fazemos aritmética de ponteiro com adição,
podemos realmente ver como funciona em termos de endereços.
Portanto, aqui neste programa, tudo o que estou fazendo é criar uma
string, uma matriz de caracteres, chamada de string.
E então estou criando um ponteiro de caractere chamado p.
Estou examinando todo o comprimento da string, que é
múltipla. Então, estou examinando todo o array.
Basta nomear básico para comprimento de força de loops de tamanho múltiplo e múltiplo.
E então estou imprimindo cada
string ou caractere real dentro dessa matriz.
E também o que estou fazendo é exibir o
endereço e, em
seguida, o endereço com o número real que adicionei a ele.
Portanto, vamos ver apenas a saída disso, porque a saída
demonstra um exemplo realmente bom de aritmética de pontos.
Então, vamos aos blocos de código e executá-los.
Então, aqui estamos em blocos de código. Eu limpei o código um pouco.
Eu uso str length, defino um strn length porque é extra include.
E eu quero apenas executar isso.
Então, quando eu executo isso, o que você notará é que está
mostrando como lembrar como é a memória, e está mostrando os valores
fazendo a aritmética de pontos. Portanto, se você disser múltiplo sub-0,
lembre-se de que múltiplo contém apenas uma string.
Mas se olharmos para isso e dissermos que olhemos para o conteúdo
do array, múltiplos de 0 é um, múltiplos de 1 é um espaço e então o resto é string.
Essa é a matriz.
Ao lado disso é o mesmo que adicionar 0 ao ponteiro
e desreferenciá-lo, adicionar 1 e adicionar 2.
E mostra como você pode fazer aritmética de ponteiro desreferenciando o
próprio ponteiro e adicionando números a ele.
Portanto, o ponteiro mais sete desreferenciando que você obtém g.
Então, na terceira coluna, estou mostrando os endereços
reais à medida que incrementamos. Portanto, os endereços de cada
elemento na matriz usando o "e" comercial apenas na matriz de
caracteres, vemos o endereço 060feff para o elemento 0 e assim por diante.
E então olhamos para os endereços se
apenas adicionarmos ao próprio ponteiro sem desreferenciá-lo, e
você verá os endereços alinhados.
E então podemos olhar a sintaxe para ver o que está acontecendo aqui em
termos da primeira coisa que realmente exibimos é o índice na matriz, que é apenas um contador.
E então exibimos um percentual c, que é
o caractere do array.
A próxima coisa que estamos exibindo é
desreferenciar o ponteiro mais I.
Portanto, aqui o que estamos fazendo é exibir I e,
em seguida, exibir a desreferência do ponteiro mais I, o
valor real.
Portanto, exibimos
como d apenas
o contador real e, em seguida, o ponto c
é a nossa desreferenciação. Portanto, p é o nosso indicador.
Estamos apenas dizendo p mais I, aritmética de ponteiro, e então
estamos desreferenciando isso.
E então, para obter os endereços,
tudo o que precisamos fazer para obter o endereço da matriz
é dizer múltiplo e comercial e o índice.
Para obter o primeiro, obtenha o endereço do ponteiro aqui, basta dizer
p mais
I para obter o contador real
que está mostrando como estamos incrementando esse p,
apenas fazemos a p mais por cento d.
Mas ele faz um bom trabalho
ao demonstrar as várias maneiras como a memória que
apontamos para os endereços
é realmente exibida e como eles são
equivalentes aos diferentes índices em uma matriz e aos ponteiros reais.
Eu pensei que isso fez um bom trabalho.
Quero ver mais um exemplo que faz outro bom trabalho em
relação à aritmética de ponteiros com longos. Porque aqui são
números inteiros. Portanto, tudo o que temos a fazer é adicionar
um e passar automaticamente para o próximo byte e assim por diante. Vamos ver o que fazemos, fazemos anseios.
Portanto, neste exemplo, eu queria apenas demonstrar como você pode fazer a mesma coisa
com um ponteiro longo e um ponteiro longo.
Com o ponteiro de caractere, era apenas uma matriz de caracteres de string.
Mas mesmo para matrizes longas, que são de tamanhos diferentes, ainda
podemos iterar por meio delas usando um ponteiro e
você pode ver como o número de bytes realmente muda.
Portanto, embora digamos que temos um ponteiro longo e adicionamos um a ele, na verdade estamos adicionando
4 bytes a ele porque um longo é um pouco maior e veremos isso neste exemplo.
Portanto, agora vamos executar este exemplo em blocos de código.
Então aqui está nosso exemplo. Novamente, temos um contador inteiro, um contador de loop.
Temos um longo array 15l.
Estamos especificando l colocando o sufixo em e, em seguida, especificamos seus
ls, seus longos temos um ponteiro longo que aponta para múltiplos.
Novamente, por ser um array, não precisamos usar o endereço do operador.
Vamos passar por todo o tempo. Aqui não podemos usar o comprimento de agitação, temos
que usar o tamanho de, e na verdade temos que dividi-lo por cada ponto na matriz.
Então, o tamanho total dividido pelo único ponto no array,
é quando queremos saltar, porque eles
lembram nossos endereços que estão aumentando em 4 bytes cada.
E, novamente, o que estamos fazendo aqui é apenas exibir o
ponteiro versus o array e mostrar como eles estão relacionados
e, em seguida, exibir o número total real de
bytes que o long está em nosso sistema.
E isso novamente apenas demonstra como os arrays
estão relacionados aos ponteiros.
Portanto, se executarmos
isso, veremos uma saída semelhante. Mas o que é um pouco diferente
aqui é o tamanho do endereço, aumentando em 4 bytes. Vamos imprimir o endereço e o ponteiro.
Então, para o endereço e o ponteiro mais
0, isso será igual ao sub
0 da matriz, que é o endereço 6356728.
E para remover a referência do ponteiro, obteremos o valor 15.
Portanto, p mais 0 ainda será igual ao array sub 0.
E então novamente fazemos o mesmo para p mais um p mais
2 ep mais 3, todos equivalentes aos pontos corretos no array para o índice.
Os endereços estão subindo 4 bytes, mas ainda podemos apenas adicionar um 2 e 3 e
vemos que os valores são os mesmos.
E então ele nos diz que este comprimento ocupa 4 bytes e é por isso que os endereços estão aumentando em 4.
O que é significativo aqui é que ainda podemos adicionar um a ele
e o compilador sabe que deve ir para o próximo endereço.
Portanto, quer tenhamos um caractere longo, ou qualquer outro tipo
de dado específico dentro do sistema, adicionar um ou
2 irá adicionar o número correto de bytes.
Então, apenas outro exemplo legal que eu
queria mostrar a vocês porque essa aritmética de ponteiro é realmente
importante e é muito útil
ao iterar ou percorrer um array, torna muito mais limpo e eficiente.
Espero que tenha ajudado. Obrigada.