Hola y bienvenido de nuevo.
En esta conferencia, quiero ir a través de
una demostración de solución de nuestro desafío anterior que era
crear algunas funciones, principalmente la función GCD y una función de pareja, función de valor absoluto y
función de raíz cuadrada.
Voy a crear un proyecto y Probablemente
voy a nombrar las funciones del proyecto, voy para cerrar mi proyecto existente aquí.
Va a ser otro aplicación de consola.
Realmente no hemos conseguido en bibliotecas o cualquier tipo de
programación gráfica.
Así va a ser como sobre algunas funciones.
Por lo general, desea tener un buen nombre allí, pero esto es
solo para fines de aprendizaje.
Así que somos algo así como proporcionando funciones genéricas.
Si fuera un programa de GCD, escribe el máximo común divisor.
Pero lo primero que vamos a hacer vamos a implementar nuestro
programa de máximo común divisor.
Esta va a ser una función que encuentra el máximo común divisor
entre dos enteros no negativos valores y luego devuelve los resultados.
Deberíamos estar proporcionando función prototipos también para que podamos llamarlos y
podamos colocar ellos en cualquier lugar de la función.
Así que hagámoslo.
Para la primera función, este es una declaración de función.
¿Por qué hacemos una función? declaración, para
que podamos invocarla en cualquier parte del programa.
En realidad no tenemos que implementar esta
función por encima de la función principal cuando la llamemos.
Y es una buena práctica, es muy fácil de aclarar para ver qué
está pasando en el programa con todas las declaraciones de funciones en la parte superior.
Esto devolverá un int.
Así que recuerda, el encabezado de la función es el primero Lo que debe hacer es especificar el tipo de
datos que se devolverán.
GCD devolverá un int.
Entonces va a nombrar la función que es GCD.
Y luego dentro de los paréntesis están datos que se pasan al GCD.
Y esto va a estar también siendo int.
Vamos a pasar dos elementos de datos.
Entonces los separamos por comas.
Especificamos el tipo de datos para cada uno y el nombre de la variable.
Solo voy a decir en u y v.
Y luego tengo el punto y coma para finalizar la definición de la función.
Ahora puedo definir mi función a continuación el principal y aún puedo invocarlo y no
llegar a tener ningún problema.
Así que ahora, cuando realmente quieras define
la función impleméntala, tu haces la misma función encabezado int valor de retorno GCD.
Tiene que coincidir con el declaración en términos de tipos.
Podrías nombrarlo de otra manera como int x para los nombres, pero vamos
a ser consistentes.
Solo vamos a decir int v.
Sabemos que es la función definición porque hay corchetes
que definen el cuerpo.
Este es el código de implementación.
El algoritmo real para el GCD es bastante simple.
Todo lo que tienes que hacer es escribir un bucle y revise el ciclo y observe los valores
de temperatura basados en los residuos.
Así que voy a crear un local variable dentro de mi función GCD.
¿Cómo sabemos que es local porque está dentro de los corchetes de 12 a 14.
Esta variable no es accesible dentro de la función principal.
Es solo local para este bloque.
Aquí solo voy a llamar a temp ya que es local.
Ahora también voy a crear mi bucle.
Voy a usar un bucle while.
Y mi bucle while solo va para ir hasta v, que sería nuestro
máximo común divisor.
Recuerde, el mayor común divisor toma dos parámetros.
Necesitaría un parámetro.
Y en base a esos dos parámetros, tiene un algoritmo para crear para
encontrar el máximo común divisor.
Entonces, si estamos tratando de encontrar el divisor,
tenemos que asegurarnos de que v no sea igual a cero, nuestro segundo parámetro.
Esto es solo estándar partes del algoritmo.
Mientras que la v no es igual a cero, vamos a
poner corchetes para el bucle.
Lo que vamos a hacer es primero vamos a
asignar la temperatura al valor de los módulos de u mod v.
Entonces te vamos a poner igual av, y vamos a establecer
v igual a temp.
Y luego queremos volver datos de esta función.
Entonces, ¿cómo devolvemos los datos de ¿Una función? usamos la palabra
clave return, y simplemente devolvemos el datos que queremos devolver.
En este caso, queremos devolver u.
Ahora recuerda que si esta función no devolvió ningún dato, tendríamos que
cambiar el tipo a anulado.
Y luego podríamos simplemente tener una devolución sin datos.
Pero esto está devolviendo datos.
Así que tenemos que emparejarnos.
Y aquí lo haríamos decir volver de nuevo u.
Además, si no estuviéramos pasando datos a esta función,
podríamos poner void como parámetros o podríamos mantenerlos vacíos y eso diría
que la función no toma datos, pero estamos pasando dos variables.
Y estas variables u y v son variables locales a la función GCD.
Podemos usarlos dentro de la función.
Y eso es lo que estamos haciendo.
Todos estos son rasgos de una función.
El valor de retorno, los datos que estás pasando, usando
variables locales y luego devolviendo datos.
Todas esas cosas a las que les prestas atención en la sintaxis con los corchetes y luego también con
la declaración en la parte superior.
Ahora queremos intentar prueba esta función.
Así que queremos probarlo para todos. tipo de cosas diferentes.
Sigamos adelante y recordemos que esto La función devuelve datos, por lo que probablemente queramos crear
una variable local en nuestro principal, simplemente lo llamaremos resultado.
Podemos inicializarlo a cero.
Y luego queremos básicamente llama a la función.
¿Cómo invocamos una función?
Solo especificamos la función nombre seguido de los datos que se
le pasan.
Porque esta función devuelve datos, voy a decir que el resultado es igual
y luego el nombre de la función.
El nombre de la función es GCD.
Y te lo voy a pasar 150 para mi primera prueba y 35.
Voy a hacer otras dos pruebas simplemente pasar números diferentes, pero lo que quiero hacer
es querer para imprimir los datos que se
devuelven como resultado.
Entonces voy a decir printf, y estoy voy a decir que el MCD de 150 y 35 es un avance
de línea porcentual y luego el resultado.
Derecha. Entonces la línea 10 es importante.
Estamos recuperando datos de GCD, por lo que lo estamos asignando a una variable.
Y podemos llamar a la función pasando en dos constantes aquí, 150 y 35.
También podríamos pasar variables.
La forma en que invocamos la función con los datos que se
le pasan está entre paréntesis, ponemos los valores separados por comas y luego el
punto y coma al final.
Quiero hacer varias pruebas.
Entonces voy a copiar las líneas 10 y 11 y solo ingrese algunos otros datos.
Voy a poner 1026 y 405 y luego también 83.
Y en realidad lo que podríamos hacer es en lugar de
devolver la variable, podríamos simplemente ponerla llamar a la
función dentro de printf e imprimirla allí mismo, ni siquiera tenemos que salvarlo.
Así que podríamos decir simplemente MCD 83, 240.
Tendríamos que cambiar lo
que estamos imprimiendo en términos de los valores codificados aquí, digamos 1026, 405 y luego también 240 y 83.
Así que sigamos adelante y compilemos eso.
Asegurémonos de conseguir sin errores ni advertencias.
No tenemos errores ni advertencias.
Así que ejecutémoslo.
Cuando lo ejecutamos, deberíamos ver el máximo común divisor
tres veces para ciertos números.
Entonces vemos que el MCD de 150 y 35 es 5.
El MCD de 1026 y 405 es 27.
Y el MCD de 83 y 240 es 1.
Máximo común divisor significa el factores que entran en esos dos números,
cuál es el factor más alto.
Entonces 5 entra en 35, y 5 entra en 150.
Y ese es el más alto.
27 también entra en 405 y 1026, eso es el más alto entre los dos.
Entonces parece que está funcionando.
Y cubrimos los conceptos básicos de pasando datos y devolviendo datos.
Ahora queremos practicar un par otras cosas en términos de solo
algoritmos y resolución de problemas.
Creemos otra función llamado valor absoluto.
La función de valor absoluto va para devolver un flotador y tomar un flotador.
Va a ser un función muy sencilla.
Entonces vamos a declarar la función en la línea cinco.
Vamos a decir flotar absoluto valor, ese es un nombre seguido de los parámetros, y estamos vamos a decir
float x, y luego vamos a terminar con
un punto y coma.
Nuevamente, observe la función declaración, el valor de retorno, los
parámetros especifican con tipos de datos y luego el nombre de la función.
Entonces podemos seguir adelante y definir esta función debajo de
la función GCD y será muy simple.
Definimos la función con el tipo que se devolverá, el nombre y
luego el parámetro, al igual que el declaración excepto que ahora tenemos corchetes para
iniciar el bloque de código.
Esto es fácil porque todo lo que tenemos que hacer es comprobar el parámetro que
está pasando y comprobar si es menor que cero.
Si es menor que cero, entonces solo vamos a asignarle
la inversa, que sería menos x.
Entonces, si es un valor negativo, se multiplicará
por menos y devolverá un positivo.
Y queremos devolver esos datos.
Entonces vamos a decir return x.
Ahora una cosa que mencioné en el conferencias
de las que no pude dar un ejemplo fue lo que si devuelve todos los datos.
Porque podríamos tener un montón de if declaraciones, y podríamos estar regresando en
cada declaración if.
Y entonces su función puede, en teoría, tienen muchas declaraciones de retorno si están
dentro de ifs o bucles.
Y luego podrías tener uno en la parte inferior.
El problema con esto es es muy difícil de seguir.
Si necesita devolver diferente partes de su código, básicamente, simplemente almacene los datos en
una variable y devuélvelo en la parte inferior.
Pero aquí esta es una función simple.
Solo estamos devolviendo un valor.
Sigamos adelante e intentemos usar esta función y es muy bueno que tome
flotadores para que podamos utilícelo con números enteros y flotantes.
Así que voy a crear un par de variables aquí
que vamos a pasar.
Y yo también voy para crear un número entero.
Voy a hacer eso en la parte superior de mi main.
Voy a crear un flotador para F1 F2 F3.
Y voy a crear un número entero I1.
Y voy a crear otro variable que almacena el resultado pero tiene
que ser flotante.
Entonces voy a tener
que crear otra variable y
esto solo va a decir resultado de valor absoluto, y lo inicializaré
a 0. 0.
Ahora voy a invocar el función e imprimir los resultados.
Entonces voy a copiar y pegue un poco de código aquí.
Puedo invocar la función y almacenar los datos que se devuelven o simplemente puedo
pasarlos a la función printf.
Probablemente quiera hacer algunos comentarios aquí probando
la función de valor absoluto.
Y cuando usas los asteriscos en un solo línea, lo resalta un poco.
Así que aquí pegué solo un montón de llamadas al absoluto. función de valor y luego muestra algunos resultados.
Así que aquí en 24, estoy llamando valor absoluto con f1.
Recuerde, f1 es un flotador.
Es igual a menos de 15. 5.
Voy a formatear el resultado e imprímalo.
Y luego yo también va a imprimir f1.
Entonces vamos a ver si el el resultado cambia
llamando a la función que la original.
Así que voy a imprimir el resultado de llamar a la
función, luego el valor original.
Esto nos dirá si cambió en absoluto.
Si fue negativo originalmente y cambiado a positivo.
Haciendo eso en múltiples líneas para múltiples pruebas.
Y luego, en la línea 37, el único La
diferencia aquí es que en lugar de almacenar el valor en una variable, Solo lo voy a imprimir.
Entonces tengo que cambiar los resultados aquí a la variable de la derecha.
Así que hagamos eso y.
Así que aquí abajo quiero hacer eso.
Cuando escribí originalmente el programa, los escribí por separado.
Así que, con suerte, no cometo errores aquí.
Y cambiar todos los que necesito para cambiar y eso debería hacerlo.
Los otros en realidad no lo son imprimiendo los resultados de
todas las variables, solo las de la línea 26.
De lo contrario, solo estamos mostrando los resultados.
El primero solo muestra que que cambió porque f1
es un valor negativo.
Bueno, construyamos esto.
No tenemos errores ni advertencias.
La salida que queremos preste atención es solo el
valor absoluto de salida.
Entonces podría ser mejor de hecho, agregue algunos avances de línea.
Después de mostrar nuestro último, agreguemos un par de feeds de línea.
Más fácil de leer y ejecutar.
Entonces ahora vemos que el resultado es 15. 5.
Entonces realmente lo cambió de negativo a positivo porque f1
originalmente era 15. 5.
Y todos los demás resultados también son valores positivos.
La última declaración impresa no se imprimió fuera del resultado, simplemente imprimió
el valor devuelto por la función.
Parece que está funcionando.
La última función que quería definir era una función de raíz cuadrada.
Esta sería una función que calcula la raíz cuadrada de un número.
Y si un argumento negativo es pasado, se mostrará un mensaje
y se devolverá un 1 negativo.
Así que definamos la declaración de esta función como raíz cuadrada
flotante y toma un flotante con cualquier nombre.
Y la raíz cuadrada en realidad va para utilizar la función de valor absoluto.
Entonces podemos definirlo arriba y seguir utilizándolo debido a la
declaración de función.
Así que vamos a definirlo y se necesita un flotador.
Así que nos estamos volviendo bastante útiles definir estas funciones, tipo de datos
para los parámetros de retorno, corchetes.
Vamos a crear un par variables locales aquí.
Estos solo pueden ser Accedido dentro del bloque.
Esto solo va a ayudar con nuestro algoritmo de raíz cuadrada.
Notarás aquí en las líneas 59, Creé una variable constante.
No hemos hablado de eso pero esa es solo una forma de crear
una constante en lugar de usar una definición.
Creamos una variable flotante llamada épsilon, es. 001, ayuda con nuestro cálculo de
raíz cuadrada para hacer seguro que está dentro de un rango determinado.
Tenemos una suposición de cuál es 1. 1 y una declaración de valor absoluto aquí.
En realidad, no necesitamos proporcionar la declaración porque la definimos en la parte
superior, así que puedo deshacerme de eso.
Ahora recuerda que tenemos que verifique los parámetros, queremos hacer la validación
de los parámetros.
Si el parámetro es menor
que cero, queremos imprimir un comentario y devolver un valor negativo.
Entonces, si x es menor que cero, imprima sacar argumento negativo a raíz cuadrada
y devolver uno negativo.
Aquí es donde vamos a tener múltiples valores
de retorno, y le mostraré cómo puede regresar una vez y ponlo en la parte inferior.
De lo contrario, tenemos nuestro algoritmo de raíz cuadrada.
No voy a explicar el algoritmo porque no es pertinente a lo
que estamos aprendiendo.
Pero básicamente, para encontrar el cuadrado raíz de un número, obtenemos su
valor absoluto al multiplicar y luego menos en la x.
Entonces, la conjetura es que vamos a adivinar.
Así que originalmente vamos a adivinar y luego verifique si
este es el algoritmo, verifique si está dentro de un cierto rango.
Y si lo es, entonces vamos para establecer nuestra suposición en algo y dividirlo por
dos y eso va para ser la conjetura que volvemos.
Entonces, en el fondo, nosotros diría volver adivinar.
Y entonces estamos usando el función de valor absoluto.
Está definido debajo de nosotros, pero tenemos nuestra declaración en la parte superior, así
que eso es bueno.
Una cosa aquí es que tenemos múltiples declaraciones de devolución.
Esto es perfectamente legal, pero debería evitarse porque es más difícil
averiguar qué está pasando.
Entonces, lo que haría aquí es probablemente almacene este negativo en una variable que
no sea conjetura, pero veamos aquí cómo podemos hacer esto.
Entonces lo que haría es adivinar se inicializa en 1. 0, y devolvemos uno
negativo.
Probablemente solo crearía otro variable llamada valor de retorno flotante.
Podemos establecer esto en 0. 0.
Y luego, antes de devolverlo aquí
porque esto está saliendo de la función matemática, puedo digamos que el valor de retorno es
igual a 1 negativo. 0 en lugar de tener la devolución.
Entonces puedo comprobar y puedo decir si el valor de retorno no es igual a
un 1 negativo. 0 porque yo no quiero
ejecutar esto si ya tengo mi número invalidado, número no válido, y podría envolver esto en una
declaración if.
Y luego, dentro de la declaración while, Puedo decir que el valor de retorno es igual a la suposición.
De esa manera estoy devolviendo la correcta cosa si fuera una entrada válida.
Y luego en lugar de regresar supongo que lo que hago es
devolver el valor de retorno.
Y este código es un poco más limpio porque solo
regresa una vez en la parte inferior y es más fácil de seguir.
Entonces el valor de retorno es negativo uno si es un argumento inválido o va
a ser el cuadrado real root si no es un argumento inválido.
Y también podríamos hacer así de simple simplemente ni siquiera verificando el
valor de retorno aquí probablemente sería más
fácil decir lo contrario y hacer el más parte del if original.
Entonces, si es un número positivo que incluso lo haría más limpio de esa
manera, no tiene esa declaración if.
Ahora tenemos que probarlo.
Sigamos adelante y probemos esto.
Solo llamaremos al funciona un montón de veces.
Diremos probar la raíz cuadrada.
No voy a hacer nada impresión elegante aquí.
Solo me aseguraré de que yo puede agregar un montón de avances de línea para
que sea más fácil de leer.
Presiona el botón Insertar allí.
Está bien. Así que ahora haré un montón de
printfs donde enviaré algunos datos buenos y valiosos y algunos datos invalidos y lo formatearé de la misma manera.
Digamos la primera llamada será la raíz cuadrada de algunas buenas raíces
cuadradas válidas.
Bueno, primero comprobaremos con un número negativo.
Así que solo diremos negativo 3 que debería imprimir un error.
De lo contrario, lo probaremos con algunos números válidos.
Entonces diremos la raíz cuadrada de 16, y simplemente pasaremos un int, se convertirán,
podría recibir algunas advertencias.
Bueno, no quiero tener ninguna advertencias, y haremos 165.
Ahora ejecutemos esto y probémoslo.
Con suerte, se compilará.
Tengo un error ortográfico con float.
Ahora, cuando lo ejecuto, con suerte, obtendremos una buena salida de raíz cuadrada.
Entonces aquí tenemos uno negativo.
Y de hecho imprimimos negativos puntuaciones de argumentos, así que eso es bueno.
Y luego los otros son, yo creo, las raíces cuadradas correctas.
Entonces parece que el la función funciona bastante bien.
Hicimos raíz cuadrada de 16 que es 4, 25 que es 5, 9 que es 3,
165 es 12. 85.
Así que cometí un error de cálculo.
Estaba tratando de pensar en 15 por 15 que es 225.
Entonces, si pongo 225 aquí, sería regresa como 15 como raíz cuadrada.
Voy a proporcionar este código fuente. para
usted para que pueda analizarlo, pero comprender las declaraciones de funciones, entender
cómo definir una función con el tipo de retorno y el
parámetros que pasan datos, comprenden las variables locales, comprenden cómo para volver solo una vez en la parte inferior.
El algoritmo en sí no es tan importante.
Espero que esto haya ayudado. Gracias.