Olá, e bem-vindo de
volta. Nesta aula, quero fornecer uma demonstração de nosso
desafio para aritmética de ponteiros e usando o modificador de constante.
Vamos trazer blocos de código. Vou criar um novo projeto. Vamos nomear este exemplo
de aritmética de um ponteiro.
Então, o que vamos fazer aqui é
determinar o comprimento de uma string usando a aritmética de pontos.
Portanto, a primeira coisa que desejo fazer é criar minha declaração de função.
Isso vai retornar o comprimento da string. Portanto, terá int como um
tipo de retorno. Vou chamá-lo de comprimento de
string, e isso apenas pegará um ponteiro, mas será um ponteiro constante.
Não queremos alterar o valor do que está apontando.
Isso significa que usaríamos a constante como a primeira palavra-chave e, em
seguida, especificaríamos o tipo, que é um caractere.
E diríamos estrela, e podemos nomeá-lo como quisermos, string.
Novamente, apenas para reiterar, se tivéssemos colocado a constante aqui em vez disso, isso
diria que o endereço do ponteiro, o valor
do ponteiro não pode mudar.
Mas, novamente, é meio redundante e realmente não precisa ser feito
porque estamos fazendo passagem por valor, passagem por cópia.
Então você tem uma cópia do endereço de qualquer maneira, então não importa se você alterá-lo lá.
Mas é importante mudar o que você está apontando. Se você não deseja que o
valor do que está apontando mude, você definitivamente deseja fazer aqui constantemente, e
isso é importante.
Agora, tudo o que precisamos fazer é criar nosso principal.
criar nosso principal. Tudo o que vamos fazer
em nosso principal é chamar string length,
uma função de comprimento de string com diferentes strings.
Então, vamos imprimir, e lembre-se, ele retorna um número inteiro para que possamos dizer por cento d
e vamos apenas imprimir o comprimento de algumas strings que passarmos.
Vamos chamar o comprimento da string
e apenas passar algumas strings constantes, então podemos colocar as
coisas entre aspas duplas aqui. Não precisamos nem criar ponteiros.
Você poderia criar um ponteiro, atribuí-lo e depois passá-lo, mas só precisa
ter certeza de que é uma constante.
Mas como é mais fácil com menos código, podemos apenas dizer teste de comprimento de string.
Novamente, essa é uma string literal constante.
Vamos testar com mais alguns.
Colocaremos um espaço depois disso. Vamos adicionar alguns feeds de linha.
Aqui vamos chamar o comprimento da string. E, na verdade, vamos chamá-lo com a
string vazia, certifique-se de virar zero. E então
no nosso terceiro vamos dizer comprimento da
corda, vamos apenas dizer Jason.
Agora, incidentalmente, quando você os cria e passa esses links de comprimento de
string, eles obtêm automaticamente o terminador nulo adicionado a eles.
Aprendemos isso quando declaramos ponteiros.
Essa é uma das vantagens. Se você for criar um ponteiro
e for um literal, não especifique o tamanho.
Você gostaria de fazer algo como caractere se for um array porque um
array é um array é um ponteiro. Mas se
não quisermos especificar o tamanho, poderíamos
dizer caractere pe, aqui dentro, poderíamos apenas dizer Jason.
Lembre-se daquela lição em que, se não especificarmos o tamanho das matrizes de caracteres,
ele adicionará automaticamente um terminador nulo e criará o tamanho para você.
Assim você não comete erros. Se você colocar o tamanho dentro da
matriz, pode não ter o terminador nulo suficiente.
É a mesma coisa quando passamos o literal para o comprimento da string,
o terminador nulo é adicionado ao final dela.
Portanto, poderíamos ter criado essas variáveis
inicialmente e feito algo assim e, em seguida,
passado em cada uma.
Mas eu não queria perder tempo criando variáveis. Então, vou fazer isso.
Agora, o que é realmente importante para este código é a função.
Então, vamos criar nosso comprimento de string. Lembre-se novamente, ele retorna um número
inteiro e será uma constante. Portanto, podemos apenas dizer string estrela char constante.
E você também percebe que o nome da variável de
declaração da função não precisa corresponder. Eu poderia colocar isso como cordas e tudo bem também.
Agora, dentro desta função, temos que criar um ponteiro local porque o ponteiro local vai
apontar para o final da string. E então, uma vez que temos o
endereço do final da string, podemos menos o endereço do início da string.
O endereço do início da string é o que é passado.
String vai apontar automaticamente para o primeiro elemento na matriz ou
o primeiro endereço da matriz.
Portanto, se criarmos um ponteiro local
e quisermos apenas criar novamente outra estrela
char constante, diremos apenas o último endereço, que tal.
E isso será igual ao endereço inicial da string, e então iremos
incrementá-lo a cada vez em nosso loop.
Portanto, agora temos o último endereço. Novamente, esta é uma variável
local que armazenará o endereço antes do terminador nulo.
Agora podemos escrever nosso loop while.
E nosso loop while vai terminar quando virmos o terminador nulo.
Agora podemos fazer isso de duas maneiras diferentes.
Podemos comparar personagens. Então poderíamos dizer algo como o
último endereço da estrela, porque temos que des-referenciar que não
é igual a barra
invertida zero poderia fazer algo assim, mas isso
é uma espécie de código. Tudo o que realmente precisamos
fazer é apenas
dizer asterisco no último endereço. Porque se você desreferenciar
um terminador nulo, ele será igual a
zero e zero será igual a falso.
Sabemos que os booleanos têm um verdadeiro, zero é falso.
Então, se for falso, vai pular. Portanto, tudo o que você
precisa fazer é inserir na sua condição while o último endereço com asterisco.
Novamente, isso vai remover a referência do ponteiro.
E uma vez que aponta para o último endereço, vai apontar para o terminador nulo.
Agora temos que nos certificar de que modificamos o último endereço, para que eventualmente aponte para o terminador nulo.
Aqui, tudo o que podemos fazer é dizer mais mais o último endereço.
Portanto, cada iteração desse loop while vai incrementar o endereço até
ver um zero.
Um zero representa o terminador nulo.
Assim, o resultado final após o término da execução
do loop while, o último endereço estará apontando para o endereço do terminador nulo.
Podemos então subtrair o endereço do terminador nulo do
endereço que foi passado, nossa string, e isso nos dará nosso comprimento.
Então, isso é tudo que temos que fazer na próxima linha. Podemos apenas dizer retornar nosso último
endereço e, na verdade,
queremos menos o endereço, portanto,
não precisamos remover a referência de nada ou usar o
operador de indireção, último endereço menos string. Assim, a string é passada, não
a modificamos de forma alguma.
Isso está apontando para o primeiro personagem. Isso estaria apontando para j.
Esse seria o endereço ou, pela primeira vez, ligamos para a linha oito, seria o endereço de s.
O último endereço vai apontar para o endereço deste último t.
Na verdade, mais um do que isso, o terminador nulo. Se dissermos o último endereço menos
o endereço de s, isso nos dará o comprimento.
E é isso que vamos devolver.
Espero que faça sentido.
Novamente, na linha 17, estamos criando uma variável
local porque precisamos controlar o último endereço, o endereço
do terminador nulo.
Após a execução do loop while, o último endereço irá apontar para depois
de t, o terminador nulo.
Então podemos apenas subtrair o último endereço da string, o endereço da
string está apontando para s quando chega, não o modificamos.
Então, vamos ver se isso nos dá o comprimento correto.
Quando executamos isso, devemos ver o comprimento das strings que passamos.
Portanto, vemos 17 0 e 5.
Vamos ver 1 2 3 4 5 6 7 8 9 10
11 12 13, você tem que contar o espaço, 14
15 16 17. Isso mesmo, colocamos aspas
duplas que estão em branco, então deve ser zero e então
Jason deve ser 5 então 17 0 e 5, isso é correto.
Então, o que fizemos aqui foi usar a
aritmética de ponteiros para obter o último endereço mais o operador
de incrementação e, em seguida, apontar
nossa aritmética para obter o comprimento, diminuindo o último endereço menos a string.
Muito arrumado. Estou tentando demonstrar o poder
da aritmética de pontos, a conveniência de notação dela.
Como você pode facilmente aumentar, diminuir para
chegar a vários pontos em uma matriz de
caracteres e retirar os caracteres. Nesse caso, estamos apenas obtendo os endereços e, em seguida,
usando os endereços para menos uns aos outros para obter o comprimento.
Espero que tenha sido útil. Certifique-se de entender tudo que acabei de mencionar.
Novamente, o conceito de uma constante, o conceito de mais mais, o conceito da
condição se você desreferenciar um endereço e isso aponta
para um terminador nulo, é um zero, então ele salta para fora então, e então
este conceito de menos dois endereços. Obrigada.