Olá, seja bem-vindo de volta. Nesta aula, quero dar uma demonstração
para nosso desafio anterior que era
entender passagem por referência, ter
um parâmetro dentro de uma função pegando um ponteiro.
Então, vamos criar um novo projeto. Chamaremos essa passagem de
ponteiro por referência porque é isso que está demonstrando,
coisas básicas aqui, novo projeto, aplicativo
de console c. Muito simples aqui.
Vamos apenas chamar esse ponteiro de passagem de
sublinhado por referência.
Novamente, demonstrando como podemos usar parâmetros dentro de uma função para
passar dados e como esses dados serão modificados
fora da função.
Portanto, a primeira coisa que faremos é criar nossa declaração de função, nosso
protótipo de função. É sempre bom fazer isso
para que você possa ligar para qualquer lugar em seu programa. Vamos apenas chamá-lo de quadrado.
O principal nesta declaração de função é que ela receberá um ponteiro.
Então, vai precisar de um ponteiro final, então vamos dizer int star e
então você pode dar a ele o nome que quiser e você termina com o ponto-e-vírgula.
E nossa função principal,
primeiro vamos fazer é apenas criar uma variável de número
inteiro regular e dizer apenas int num e apenas código rígido para 9.
E o que vamos fazer é chamar nossa função quadrada.
Nossa função quadrada não retornará nenhum dado, ela será nula.
Temos que passar um endereço agora porque nossa função quadrada na linha 4 está pegando um ponteiro.
Portanto, não podemos passar um num, teríamos que realmente passar o endereço de num, e
então terminaríamos com um ponto e vírgula. Portanto, chamamos a função usando
o nome da função e, em seguida, passando o endereço da variável.
Porque a variável aqui em uma linha oito não é um ponteiro.
Então, podemos basicamente imprimir o valor de num.
E, novamente, o que você notará aqui é que, porque
estamos passando o endereço, se alterarmos os dados na própria função para essa
variável, ela vai mudar fora dela. Então, aqui vamos dizer que
o quadrado do número dado é e é apenas por cento
d, vamos adicionar uma alimentação de
linha e vamos apenas imprimir num, e num não
será 9. , Eu vou te dizer isso.
E então vamos retornar 0 para nossa função regular.
Portanto, agora temos que realmente implementar a função, defini-la.
Para defini-lo, vou apenas dizer quadrado vazio.
Sabemos que é necessário um ponteiro de inteiro, então direi int star x.
E agora queremos apenas multiplicá-lo por si mesmo.
Mas queremos ter certeza de não mudar o endereço.
Então, o que poderíamos fazer aqui é tornar isso uma constante, mas
você gostaria de colocar a constante
após o tipo de dados porque não queremos alterar
o valor de x ou o endereço do que está apontando, então poderíamos dizer constante int.
Se não quiséssemos alterar o valor
de x, diríamos constante. Mas queremos alterar o valor de x, vamos elevá-lo ao quadrado sozinho.
Então, para elevar ao quadrado por si mesmo, primeiro, o que queremos
alterar é o valor final de x. Portanto, temos que usar o
operador de indireção. Temos que desreferenciá-lo com o asterisco.
E então vamos dizer igual, não queremos fazer
x vezes x porque isso só vai multiplicar os endereços. X é um ponteiro, não queremos apenas obter o
valor de x, queremos obter o valor para o qual x está apontando.
Então, novamente, temos que des-referenciá-lo e então
vamos multiplicá-lo por ele mesmo. Vamos retirar a referência duas vezes.
Pode ser uma boa ideia colocar
isso entre parênteses para que seja facilmente entendido o que está acontecendo aqui.
Você está desreferenciando o ponteiro, obtendo o valor dele e então multiplicando
por seu valor e então você apenas adiciona o ponto-e-vírgula, e isso
é tudo que você precisa fazer. Portanto, quando executarmos este programa, ele
imprimirá 81.
Vai imprimir o valor de num. Num vai mudar dentro do quadrado porque
estamos passando o endereço lá.
Não podemos realmente alterar o valor do ponteiro, então
temos a constante após o tipo.
Então aqui dizemos build e parece que
não alteramos a declaração.
E agora queremos apenas ter certeza de que todo
o resto está correto.
Se você quiser que o ponteiro seja constante,
você deve colocá-lo após o asterisco.
Portanto, int start constant significa
que você não pode alterar o valor de
x, que é o endereço de num.
Se colocarmos const antes do int
ou depois da entrada antes do asterisco, isso significa
que você não pode alterar o valor para o qual o ponteiro está apontando.
Portanto, agora, quando executarmos isso, devemos ver como saída 81.
Novamente, o que isso
nos diz é que modificamos os
dados. Esta variável,
esta variável local num foi modificada dentro da função e seu valor alterado.
Isso não é normal. Não aprendemos esse conceito até agora. Isso é passado por referência.
Mas em c o que está acontecendo é que você está passando uma cópia do endereço.
É por isso que é realmente redundante, nem precisamos da constante, porque mesmo
que mudássemos o valor do ponteiro, é uma
cópia do valor do ponteiro, então você realmente não precisa fazer isso.
Agora, se não quisermos usar um número existente, podemos criar um
ponteiro, basta alocar memória para ele.
Então, o que teríamos que fazer aqui é criar uma estrela num int.
Mas o que teríamos que fazer é primeiro lançar o malloc
porque o malloc volta com um
ponteiro void, mas podemos alocar memória dinamicamente.
E aqui, teríamos que dizer realmente,
só porque estamos criando um inteiro, poderíamos apenas dizer o tamanho
de int e isso alocaria memória para nós.
E então, tudo o que teríamos que fazer é passar para o quadrado num.
E então, quando
construirmos isso, ele faria a mesma coisa, mas
agora não tem um valor para num
também, então não saberia realmente
o que calcular, então você teria que realmente
atribuir ao valor de num vamos dizer aqui
quatro, você remova a referência. E agora, quando você constrói e
executa, deve obter 16.
Agora, a única coisa aqui é que queremos imprimir o valor, então queremos dizer num.
E então, quando o executarmos, devemos ver 16.
E é realmente o mesmo tipo de
comportamento, e vemos 16.
A única diferença aqui é que estávamos alocando memória para
o que o ponto está apontando, em vez de apenas apontar para um local de
memória existente com o e comercial.
Novamente, coisas importantes a serem observadas aqui, esse número está mudando
fora da função. Isso é
passado por referência para entender. Onde estamos usando o operador de referência, o
operador de indireção para obter o valor para o qual o ponto está apontando.
Entenda que se a função recebe um ponteiro e temos
um ponteiro, podemos apenas enviar o nome.
Se ele não está pegando um
ponteiro e é na verdade um valor,
então temos que desreferenciá-lo. E isso é exatamente como o scanf.
Portanto, aqui teríamos que dizer o "e" comercial.
E também quando o imprimirmos, não teríamos
que des-referenciar nada porque não é um ponteiro e então
seria a mesma coisa aqui.
E então entenda const dois. Const antes da estrela int está dizendo que
o valor para o qual o ponto está apontando não pode mudar.
O const após o início do int está dizendo que o endereço do ponteiro não pode alterar o valor do ponteiro.
Eu espero que isso tenha sido útil.
Novamente, brinque com isso, mude alguma sintaxe, bagunce como eu fiz.
Isso o ajudará a aprender muito. Obrigada.