Olá, seja bem-vindo de volta.
Nesta palestra, eu quero ir através de uma
demonstração de solução de nosso desafio anterior que era criar
algumas funções, principalmente a função GCD e um função de casal, função de valor absoluto e
função de raiz quadrada.
Vou criar um projeto, e Provavelmente
vou nomear as funções do projeto, vou para fechar meu projeto existente aqui.
Vai ser outro Aplicação de console.
Nós realmente não temos em bibliotecas ou qualquer tipo de
programação gráfica.
Vai ser assim sobre apenas algumas funções.
Normalmente, você quer ter um bom nome lá, mas isso é
apenas para fins de aprendizagem.
Então, estamos meio que fornecendo funções genéricas.
Se fosse um programa GCD, eu escreva o maior divisor comum.
Mas a primeira coisa que vamos fazer vamos implementar nosso
programa de maior divisor comum.
Esta será uma função que encontra o maior divisor comum entre dois
inteiros não negativos valores e, em seguida, retorna os resultados.
Devíamos estar fornecendo função protótipos também para que possamos chamá-los
e colocar -los em qualquer lugar da função.
Então vamos fazer isso.
Para a primeira função, este é uma declaração de função.
Por que fazemos uma função declaração, para
que possamos invocá-lo em qualquer lugar do programa.
Não temos que realmente implementar esta
função acima da função principal quando a chamarmos.
E é apenas uma boa prática, é muito fácil de ver o
que está acontecendo no programa com todos os declarações de função na parte superior.
Isso vai retornar um int.
Portanto, lembre-se, o cabeçalho da função primeiro a única coisa que você faz é especificar o tipo de dados
que será retornado.
GCD vai retornar um int.
Vai então nomear a função que é GCD.
E então dentro dos parênteses estão dados que estão sendo passados para o GCD.
E isso vai também estar int.
Vamos passar dois itens de dados.
Então, nós os separamos por vírgulas.
Nós especificamos o tipo de dados para cada um e o nome da variável.
Vou apenas dizer em u e v.
E então eu tenho o ponto e vírgula para terminar a definição da função.
Agora posso definir minha função abaixo o principal e ainda posso invocá-lo e
não conseguir ter nenhum problema.
Então, agora, quando você realmente quiser definir
a função implementá-la, você faz a mesma função cabeçalho int valor de retorno GCD.
Tem que combinar com o declaração em termos de tipos.
Você poderia nomeá-lo de outra forma como int x para os nomes, mas
vamos ser consistentes.
Vamos apenas dizer int v.
Nós sabemos que é a função definição porque há
colchetes que definem o corpo.
Este é o código de implementação.
O algoritmo real para o GCD é bastante simples.
Tudo que você precisa fazer é escrever um loop e percorra o loop e observe os valores
da temperatura com base nos remanescentes.
Vou criar um local variável dentro da minha função GCD.
Como sabemos que é local porque está dentro dos colchetes de 12 a 14.
Esta variável não está acessível dentro da função principal.
É apenas local para este bloco.
Aqui estou indo para chamada temporária, pois é local.
Também vou criar meu loop.
Vou usar um loop while.
E meu loop while está indo ir até v, que seria nosso
maior divisor comum.
Lembre-se, o maior comum divisor leva dois parâmetros.
Seria necessário um parâmetro.
E com base em ambos os parâmetros, ele tem um algoritmo para criar para
encontrar o maior divisor comum.
Então, se estamos tentando encontrar o divisor, temos
que nos certificar de que v não é igual a zero, nosso segundo parâmetro.
Isso é apenas padrão partes do algoritmo.
Enquanto v não é igual para zero, vamos colocar
colchetes para o loop.
O que vamos fazer é indo primeiro
atribuir a temperatura ao valor dos módulos de u mod v.
Em seguida, vamos definir você igual av, e vamos definir
v igual a temp.
E então queremos voltar dados desta função.
Então, como retornamos dados de uma função? usamos a palavra-chave
return e apenas retornamos o dados que queremos retornar.
Nesse caso, queremos retornar u.
Agora lembre-se que se esta função não retornou nenhum dado, teríamos que
alterar o tipo para void.
E então nós poderíamos apenas tem um retorno sem dados.
Mas isso está retornando dados.
Portanto, temos que nos corresponder.
E aqui vamos nós diga voltar novamente u.
Além disso, se não estivéssemos passando dados a esta
função, podemos colocar void como os parâmetros ou podemos mantê-los vazios e isso
diria que a função não leva dados, mas estamos passando duas variáveis.
E essas variáveis u e v são variáveis locais para a função GCD.
Podemos usá-los dentro da função.
E é isso que estamos fazendo.
Todos esses são traços de uma função.
O valor de retorno, os dados que você está passando, usando
variáveis locais e, em seguida, retornando dados.
Todas essas coisas prestam atenção em a sintaxe com os colchetes e também com
a declaração no topo.
Agora queremos tentar teste esta função.
Então, queremos testá-lo para todos tipos de coisas diferentes.
Vamos seguir em frente e lembrar que este função retorna dados, então provavelmente queremos criar uma
variável local em nosso principal, vamos chamá-lo apenas de resultado.
Podemos inicializá-lo para zero.
E então nós queremos basicamente chame a função.
Como invocamos uma função?
Nós apenas especificamos a função nome seguido pelos dados que estão sendo
transmitidos a ele.
Porque esta função retorna dados, vou ter que dizer resultado igual e,
em seguida, o nome da função.
O nome da função é GCD.
E vou passar 150 para meu primeiro teste e 35.
Vou fazer dois outros testes passar números diferentes, mas o que eu quero fazer
é para imprimir os dados que estão sendo
retornados como resultado.
Vou dizer printf e estou vamos dizer que o GCD de 150 e 35 é o percentual
de alimentação de linha e o resultado.
Direito. Portanto, a linha 10 é importante.
Estamos recebendo dados do GCD, então estamos atribuindo isso a uma variável.
E podemos chamar a passagem de função em duas constantes aqui, 150 e 35.
Também podemos passar variáveis.
A maneira como invocamos a função com os dados passados para
ele estão entre parênteses, colocamos os valores separados por vírgulas e o
ponto-e-vírgula está no final.
Eu quero fazer vários testes.
Vou copiar as linhas 10 e 11 e apenas inserir alguns outros dados.
Vou colocar em 1026 e 405 e também 83.
E, na verdade, o que podemos fazer é em vez de
retornar a variável, poderíamos apenas colocá-la no chamar a
função dentro do printf e imprimi-lo ali mesmo, nem mesmo precisamos salvá-lo.
Então, poderíamos apenas dizer GCD 83, 240.
Teríamos que mudar o
que estamos imprimindo em termos de valores embutidos em código aqui, digamos 1026, 405 e também 240 e 83.
Então, vamos compilar isso.
Vamos ter certeza de obter sem erros ou avisos.
Não temos erros e avisos.
Então, vamos executá-lo.
Quando o executamos, devemos ver o máximo divisor comum
três vezes para certos números.
Portanto, vemos que o GCD de 150 e 35 é 5.
O GCD de 1026 e 405 é 27.
E o GCD de 83 e 240 é 1.
O maior divisor comum significa o fatores que entram nesses dois números,
qual é o fator mais alto.
Então, 5 vai para 35, e 5 vai para 150.
E esse é o mais alto.
27 também vai para 405 e 1026, que é o mais alto entre os dois.
Parece que está funcionando.
E cobrimos o básico de passando dados e retornando dados.
Agora queremos praticar alguns outras coisas apenas em termos de
algoritmos e resolução de problemas.
Vamos criar outra função chamado de valor absoluto.
A função de valor absoluto está indo para retornar um flutuador e obter um flutuador.
Vai ser um função muito simples.
Então, vamos declarar a função na linha cinco.
Vamos dizer float absoluto valor, esse é um nome seguido pelos parâmetros, e estamos apenas
vamos dizer float x, e então vamos
terminar um ponto-e-vírgula.
Novamente, observe a função declaração, o valor de retorno,
os parâmetros especifica com tipos de dados e o nome da função.
Podemos então prosseguir e definir esta função abaixo da função
GCD e vai ser muito simples.
Definimos a função com o tipo que será retornado, o nome
e o parâmetro, assim como o declaração exceto que agora temos colchetes para
iniciar o bloco de código.
Isso é fácil porque tudo o que temos que fazer é verificar o parâmetro que
está passando e verificar se é menor que zero.
Se for menor que zero, então vamos apenas atribuir
o inverso, que seria menos x.
Então, se for um valor negativo, vai se multiplicar por
um menos e retornar um positivo.
E queremos retornar esses dados.
Então, vamos dizer return x.
Agora, uma coisa que mencionei no palestras
que eu não consegui fornecer um exemplo foi o que se você retornar todos os dados.
Porque poderíamos ter um monte de if, e poderíamos retornar em cada
instrução if.
E assim sua função pode, em teoria, tem muitas instruções de retorno se estiverem
dentro de ifs ou loops.
E então você poderia tem um na parte inferior.
O problema com isso é é realmente difícil de seguir.
Se você precisar devolver diferente partes do seu código, basicamente, apenas armazene os dados
em uma variável e devolvê-lo na parte inferior.
Mas aqui esta é uma função simples.
Estamos apenas devolvendo um valor.
Vamos tentar usar esta função e é muito bom que ela tenha
flutuadores para que possamos use-o com inteiros e flutuantes.
Então vou criar algumas variáveis aqui que
vamos passar.
E eu também vou para criar um inteiro.
Eu vou fazer isso no topo do meu principal.
Vou criar um flutuador para F1 F2 F3.
E vou criar um inteiro I1.
E vou criar outro variável que armazena o resultado, mas deve
ser um float.
Vou ter que
criar outra variável e isso
vai apenas dizer resultado de valor absoluto, e vou inicializar isso
para 0. 0
Agora vou invocar o função e imprimir os resultados.
Vou copiar e cole algum código aqui.
Posso invocar a função e armazenar os dados que são retornados ou posso apenas
passá-los para a função printf.
Provavelmente quero fazer alguns comentários aqui testando
a função de valor absoluto.
E quando você usa os asteriscos em um único linha, meio que a destaca um pouco.
Então aqui eu colei um monte de chamadas para o absoluto função de valor e, em seguida, exibidos alguns resultados.
Então aqui em 24, estou ligando valor absoluto com f1.
Lembre-se, f1 é um float.
É igual a 15 negativos. 5
Vou formatar o resultado e imprimi-lo.
E então eu também sou vai imprimir f1.
Então, vamos ver se o o resultado muda
chamando a função do que o original.
Vou imprimir o resultado da chamada da função, em
seguida, o valor original.
Isso nos dirá se mudou em tudo.
Se fosse negativo originalmente e mudou para positivo.
Fazendo isso em vários linhas para vários testes.
E então na linha 37, o único
diferença aqui é que em vez de armazenar o valor em uma variável, Vou apenas imprimir.
Então eu tenho que mudar os resultados aqui para a variável certa.
Então vamos fazer isso e.
Então aqui embaixo, eu quero fazer isso.
Quando eu escrevi originalmente o programa, eu os escrevi separadamente.
Então, esperançosamente, não cometo erros aqui.
E mude todos os que eu preciso mudar e isso deve bastar.
Os outros realmente não são imprimir os resultados de todas
as variáveis, apenas as da linha 26.
Caso contrário, somos apenas mostrando os resultados.
O primeiro apenas mostra que que mudou porque f1
é um valor negativo.
Bem, vamos construir isso.
Não temos erros ou avisos.
A saída que queremos preste atenção é apenas a
saída de valor absoluto.
Então pode ser melhor na verdade, adicione alguns avanços de linha.
Depois de exibirmos nosso último, vamos adicionar alguns feeds de linha.
Mais fácil de ler e executar.
Portanto, agora vemos que o resultado é 15. 5
Então realmente mudou de negativo para positivo porque f1
era originalmente 15. 5
E todos os outros resultados também são valores positivos.
A última declaração de impressão não foi impressa fora o resultado, ele apenas
imprimiu o valor retornado da função.
Parece que está funcionando.
A última função que eu queria definir era uma função de raiz quadrada.
Esta seria uma função que calcula a raiz quadrada de um número.
E se um argumento negativo for aprovada, uma mensagem será exibida
e o negativo 1 será retornado.
Então, vamos definir a declaração de esta função como raiz quadrada
float e leva um float com qualquer nome.
E a raiz quadrada está realmente indo para usar a função de valor absoluto.
Podemos definir isso acima e ainda usá-lo por causa da
declaração da função.
Então, vamos definir isso, e é preciso flutuar.
Então, estamos ficando muito úteis em definindo essas funções, tipo de dados
para parâmetros de retorno, colchetes.
Vamos criar alguns variáveis locais aqui.
Estes só podem ser acessado dentro do bloco.
Isso só vai ajudar com nosso algoritmo de raiz quadrada.
Você notará aqui nas linhas 59, Eu criei uma variável constante.
Nós não falamos sobre isso, mas isso é apenas uma maneira de criar
uma constante, em vez de usar um define.
Criamos uma variável float chamada épsilon, é. 001, ajuda com nosso cálculo de
raiz quadrada a fazer certeza de que está dentro de um determinado intervalo.
Temos um palpite que é 1. 1 e uma declaração de valor absoluto aqui.
Na verdade, não precisamos fornecer a declaração porque nós a definimos no
topo, então posso me livrar dela.
Agora lembre-se que temos que verifique os parâmetros, queremos fazer a
validação dos parâmetros.
Se o parâmetro for menor
que zero, queremos imprimir um comentário e retornar um valor negativo.
Então, se x for menor que zero, imprima retira o argumento negativo para a raiz
quadrada e retorna um negativo.
É aqui que vamos ter vários valores de
retorno, e mostrarei como você pode retornar uma vez e apenas colocá-lo na parte inferior.
Caso contrário, temos nosso algoritmo para raiz quadrada.
Eu não vou explicar o algoritmo porque não é pertinente ao
que estamos aprendendo.
Mas basicamente, para encontrar o quadrado raiz de um número, obtemos o valor
absoluto dele multiplicando ele e, em seguida, menos no x.
Portanto, o palpite é que vamos adivinhar.
Então, originalmente, vamos adivinhar e então verifique se este
é o algoritmo, verifique se está dentro de um determinado intervalo.
E se for, então vamos para definir nosso palpite para algo e dividi-lo por dois
e isso vai para ser o palpite de que retornamos.
Então, no fundo, nós diria estimativa de retorno.
E então estamos usando o função de valor absoluto.
É definido abaixo de nós, mas temos nossa declaração no topo,
então isso é bom.
Uma coisa aqui é que temos várias instruções de retorno.
Isso é perfeitamente legal, mas deveria ser evitado porque é mais difícil
descobrir o que está acontecendo.
Então o que eu faria aqui é provavelmente armazene este negativo em uma variável diferente
de estimativa, mas vamos ver aqui como podemos fazer isso.
Então o que eu faria é adivinhar é inicializado em 1. 0, e estamos retornando
um negativo.
Eu provavelmente criaria outro variável chamada valor de retorno flutuante.
Podemos definir isso como 0. 0
E então antes de devolvê-lo aqui
porque isso está saindo da função matemática, posso apenas digamos que o valor de retorno seja
igual a 1 negativo. 0 em vez de ter o retorno.
Então posso verificar e posso dizer se o valor de retorno não for igual
a 1 negativo. 0 porque eu não quero executar
isso se eu já tiver meu número de invalidação, número inválido, e eu poderia embrulhar isso em uma
instrução if.
E então, dentro da instrução while, Posso dizer que o valor de retorno é igual a suposição.
Assim estou retornando o correto coisa se fosse uma entrada válida.
E então ao invés de retornar acho que o que eu faço
é retornar o valor de retorno.
E este código é um pouco mais limpo porque
só retorna uma vez na parte inferior e é mais fácil de seguir.
Portanto, o valor de retorno é negativo um se for um argumento inválido ou se
for o quadrado real root se não for um argumento inválido.
E também podemos fazer isso é simples, simplesmente nem mesmo verificando o
valor de retorno aqui provavelmente seria mais fácil
apenas dizer outra coisa e fazer o outra parte do original se.
Então, se for um número positivo que até mesmo o deixaria mais limpo, de forma
que você não tem essa instrução if.
Agora precisamos testá-lo.
Vamos testar isso.
Vamos apenas ligar para o funcionar um monte de vezes.
Diremos testando raiz quadrada.
Eu não vou fazer nada impressão extravagante aqui.
Eu só vou ter certeza que eu pode adicionar um monte de alimentações de linha para
que seja mais fácil de ler.
Aperte o botão inserir lá.
Tudo bem. Então agora vou fazer um monte de
printfs onde enviarei alguns dados válidos e válidos e alguns dados inválidos e vou formatar da mesma maneira.
Vamos apenas dizer a primeira chamada será a raiz quadrada de algumas boas raízes
quadradas válidas.
Bem, primeiro vamos verificar com um número negativo.
Então, vamos dizer apenas 3 negativo isso deve imprimir um erro.
Caso contrário, vamos testá-lo com alguns números válidos.
Então, vamos dizer a raiz quadrada de 16, e passaremos um int, eles serão convertidos,
posso receber alguns avisos.
Bem, eu não quero receber nenhum avisos, e faremos 165.
Agora vamos rodar e testar.
Com sorte, ele irá compilar.
Eu tenho um erro de ortografia com float.
Agora, quando eu o executar, espero, obteremos uma boa saída de raiz quadrada.
Então aqui temos um negativo.
E imprimimos negativos pontuação do argumento, então isso é bom.
E então os outros são, eu acredite, as raízes quadradas corretas.
Então, parece que função funciona muito bem.
Fizemos raiz quadrada de 16 que é 4, 25 que é 5, 9 que é 3,
165 é 12. 85
Então eu fiz alguns erros de cálculo lá.
Eu estava tentando pensar em 15 vezes 15, que é 225.
Então, se eu colocasse 225 aqui, volte a 15 como uma raiz quadrada.
Vou fornecer este código-fonte para você, para
que possa analisá-lo, mas entenda as declarações de função, entender como
definir uma função com o tipo de retorno e o
parâmetros passando dados, entenda as variáveis locais, entenda como para retornar apenas uma vez na parte inferior.
O próprio algoritmo não é tão importante.
Espero que tenha ajudado. Obrigada.