1
00:00:01,040 --> 00:00:01,900
Hola y bienvenidos.

2
00:00:01,940 --> 00:00:05,560
Vamos a ver a continuación la sintaxis para definir una función en el lenguaje C.

3
00:00:05,840 --> 00:00:06,630
Están listos?

4
00:00:06,710 --> 00:00:07,160
Vamos.

5
00:00:08,190 --> 00:00:08,400
Bien.

6
00:00:08,400 --> 00:00:12,570
Básicamente, la sintaxis para definir una función en el lenguaje C es la siguiente.

7
00:00:12,840 --> 00:00:17,130
En primer lugar, tenemos que especificar el tipo de dato que va a devolver nuestra función.

8
00:00:17,370 --> 00:00:20,220
Según hemos comentado, el tipo de retorno puede ser opcional.

9
00:00:20,500 --> 00:00:24,660
Y a continuación vamos a ver algunos tipos de retorno que puede devolver una función.

10
00:00:24,900 --> 00:00:27,870
Posteriormente vamos a tener el nombre de nuestra función.

11
00:00:27,990 --> 00:00:32,850
También vamos a tener ciertas reglas, muy similar a lo que ya vimos en variables para definir el nombre

12
00:00:32,850 --> 00:00:37,580
de una función y posteriormente, entre paréntesis, podemos tener parámetros también.

13
00:00:37,590 --> 00:00:43,340
Estos parámetros son opcionales y después de que cerramos estos paréntesis, abrimos un bloque de código,

14
00:00:43,350 --> 00:00:48,960
podemos ver que abrimos una llave y posteriormente cerramos la llave y todo lo que esté dentro de estas

15
00:00:48,960 --> 00:00:51,720
llaves se le conoce como el cuerpo de la función.

16
00:00:52,080 --> 00:00:56,850
Así que, por ejemplo, algunos tipos de retorno podemos observar que puede ser el tipo void, el tipo

17
00:00:56,850 --> 00:01:02,580
int, el tipo float, etc en el caso de que la función no regrese ningún valor, entonces para ello

18
00:01:02,580 --> 00:01:05,490
precisamente se va a utilizar la palabra reservada void.

19
00:01:05,790 --> 00:01:08,470
Esta palabra de void significa vacío en español.

20
00:01:08,490 --> 00:01:13,020
Esto quiere decir que no va a regresar ningún tipo de valor y entonces la función simplemente ejecuta

21
00:01:13,020 --> 00:01:15,880
su código y al terminar solamente se regresa el control.

22
00:01:15,900 --> 00:01:17,190
Como vamos a ver más adelante.

23
00:01:17,340 --> 00:01:19,290
Pero no regresa ningún tipo de información.

24
00:01:19,590 --> 00:01:20,280
Posteriormente.

25
00:01:20,280 --> 00:01:23,880
El nombre de la función normalmente es un verbo o una acción a realizar.

26
00:01:24,150 --> 00:01:27,630
También se inicia con minúscula y vamos a aplicar el concepto de camel keys.

27
00:01:27,690 --> 00:01:31,920
Pero la diferencia de una variable es que el nombre de una función normalmente es una acción.

28
00:01:31,920 --> 00:01:32,640
Es un verbo.

29
00:01:32,910 --> 00:01:34,920
La tarea que va a realizar esta función.

30
00:01:35,340 --> 00:01:40,110
Posteriormente, entre paréntesis, hemos comentado que esta información es opcional y esas variables

31
00:01:40,110 --> 00:01:42,630
se dice que son variables locales a esta función.

32
00:01:42,870 --> 00:01:47,970
Así que vamos a ir desmenuzando cada uno de estos conceptos y cuando termina de ejecutarse nuestra función,

33
00:01:47,970 --> 00:01:50,250
normalmente va a tener la palabra reservada return.

34
00:01:50,460 --> 00:01:54,660
Esta también es opcional en caso de que la función no regrese ningún tipo de información.

35
00:01:54,660 --> 00:01:58,950
Pero si regresa alguna información, entonces es la última línea que va a tener nuestra función.

36
00:01:59,220 --> 00:02:03,300
En este caso va a retornar un valor del mismo tipo que haya especificado la función.

37
00:02:03,570 --> 00:02:08,370
Así que tiene que coincidir este tipo de retorno con el valor que va a retornar nuestra función.

38
00:02:08,640 --> 00:02:12,420
Bien, esta es la sintaxis general de una función y vamos a continuar con más temas relacionados con

39
00:02:12,420 --> 00:02:13,020
funciones.

40
00:02:13,620 --> 00:02:18,630
Ahora vamos a ver cómo declarar una función y también cómo utilizarla, ya que no basta con declarar

41
00:02:18,630 --> 00:02:23,850
la función, sino que también tenemos que mandarla llamar para que se ejecute ese bloque de código reutilizable,

42
00:02:24,090 --> 00:02:27,540
es decir, que se ejecute la tarea para la cual fue creada dicha función.

43
00:02:27,690 --> 00:02:31,740
Así que, en primer lugar, en este caso vamos a definir una función que se llame Imprimir.

44
00:02:31,920 --> 00:02:36,450
Esta función no va a regresar ningún tipo de información, solamente va a mandar a imprimir cierta información

45
00:02:36,450 --> 00:02:37,140
a consola.

46
00:02:37,320 --> 00:02:41,310
No es lo mismo mandar a imprimir información a consola que regresar un valor.

47
00:02:41,610 --> 00:02:45,960
Así que esta función va a recibir cierta información, va a ser un valor de tipo entero.

48
00:02:46,170 --> 00:02:49,260
Y entonces abrimos y cerramos nuestro bloque de código.

49
00:02:49,260 --> 00:02:53,790
Y dentro de la función, dentro del cuerpo de la función, simplemente vamos a mandar a imprimir la

50
00:02:53,790 --> 00:02:56,250
variable que estamos recibiendo, la variable de parámetro.

51
00:02:56,640 --> 00:02:59,390
Así que esta variable de parámetro se convierte en una variable local.

52
00:02:59,400 --> 00:03:04,530
A Este método se crea cuando se van a llamar a este método y se destruye cuando termina de ejecutarse

53
00:03:04,530 --> 00:03:05,220
este método.

54
00:03:05,520 --> 00:03:07,860
En este caso es lo mismo una función que un método.

55
00:03:08,070 --> 00:03:10,830
Así que por ahí en ocasiones voy a utilizar la palabra función o método.

56
00:03:10,980 --> 00:03:15,540
Es exactamente lo mismo y entonces con eso tenemos apenas la declaración de nuestra función.

57
00:03:15,540 --> 00:03:19,080
Simplemente recibe cierta información y la va a mandar a imprimir a consola.

58
00:03:19,230 --> 00:03:22,620
Pero como segundo paso tenemos que mandar a llamar nuestra función.

59
00:03:22,710 --> 00:03:27,990
Así que vamos a ver ahora, por ejemplo, desde el programa principal podemos mandar a llamar esta función,

60
00:03:28,260 --> 00:03:33,030
así que podemos tener ciertas líneas de código, pero en cierto punto de nuestro programa podemos mandar

61
00:03:33,030 --> 00:03:35,670
a llamar la función para mandar a llamar la función.

62
00:03:35,670 --> 00:03:40,440
Podemos observar que vamos a utilizar simplemente el nombre de la función y entre paréntesis vamos a

63
00:03:40,440 --> 00:03:43,590
proporcionar la información que requiere nuestra función.

64
00:03:43,740 --> 00:03:48,030
En este caso estamos pasando el valor de 100 y se va a asignar a la variable de parámetro.

65
00:03:48,270 --> 00:03:52,320
Así que cuando se van a llamar la función de imprimir, la variable de parámetro se va a inicializar

66
00:03:52,320 --> 00:03:55,320
con el valor de 100, así que es el valor que se va a mandar a imprimir.

67
00:03:55,620 --> 00:04:00,270
Bien, sin embargo, la ventaja de las funciones es que podemos mandarlas a llamar tantas veces como

68
00:04:00,270 --> 00:04:05,340
necesitemos, así que podemos tener más líneas de código y en cierto momento de nuestro programa podemos

69
00:04:05,340 --> 00:04:07,290
volver a mandar, a llamar nuestra función.

70
00:04:07,290 --> 00:04:11,310
Y por ejemplo, en este caso podemos observar que en lugar del valor de 100, ahora le pasamos un valor

71
00:04:11,310 --> 00:04:13,290
distinto el valor de 200.

72
00:04:13,620 --> 00:04:16,650
Y entonces con eso vamos a conseguir reutilizar nuestro código.

73
00:04:16,860 --> 00:04:20,280
Por ello es que ahora nuestros programas son modulares y reutilizables.

74
00:04:20,700 --> 00:04:23,520
Ahora sí se ejecutarán nuestro programa principal.

75
00:04:23,760 --> 00:04:28,620
Entonces podemos observar que inicia la ejecución desde la parte superior hacia la parte inferior,

76
00:04:28,620 --> 00:04:33,570
como ya sabemos, y en cuanto llega la llamada a la función imprimir, se detiene la ejecución de nuestro

77
00:04:33,570 --> 00:04:38,520
programa principal, se pone en pausa y entonces se ejecuta la función de imprimir.

78
00:04:38,700 --> 00:04:41,280
Así que se cede el control de la función principal.

79
00:04:41,280 --> 00:04:43,200
Y ahora vamos a la función de imprimir.

80
00:04:43,350 --> 00:04:48,690
La función principal se pone en pausa y ahora en la memoria se va a ejecutar nuestra función de imprimir.

81
00:04:49,020 --> 00:04:52,590
Así que podemos observar que se crea la variable de parámetro en memoria.

82
00:04:52,590 --> 00:04:57,120
Es una variable local al método e imprimir y además recibe el valor de 100.

83
00:04:58,430 --> 00:05:04,040
Así que lo que sucedió es que se pasa esta información a la variable de parámetro y entonces se inicializa

84
00:05:04,040 --> 00:05:04,940
con el valor de 100.

85
00:05:05,390 --> 00:05:09,440
Y entonces ahora lo que sucede es que la función de imprimir se va a ejecutar de igual manera desde

86
00:05:09,440 --> 00:05:11,570
la parte superior hacia la parte inferior.

87
00:05:11,750 --> 00:05:13,880
En este caso solamente tiene una línea de código.

88
00:05:14,040 --> 00:05:18,770
Es para que entendamos el proceso de declaración, uso y ejecución de una función.

89
00:05:19,400 --> 00:05:23,720
Así que en este caso simplemente va a mandar a imprimir el valor de 100, ya que es la información que

90
00:05:23,720 --> 00:05:25,750
se le está mandando a nuestra función de imprimir.

91
00:05:25,760 --> 00:05:31,700
Se imprime este valor de 100 en consola y entonces se regresa el control a la función principal.

92
00:05:31,790 --> 00:05:34,910
Podemos ver que en este caso no está regresando ningún tipo de información.

93
00:05:34,940 --> 00:05:37,460
La función de imprimir solamente mandó a imprimir el valor de 100.

94
00:05:37,670 --> 00:05:41,840
Regresa el control en la función principal y continuamos con las demás líneas de código.

95
00:05:42,140 --> 00:05:47,510
Así que se reanuda la ejecución del programa principal y si encontramos de nueva cuenta una función,

96
00:05:47,510 --> 00:05:49,760
en este caso de nueva cuenta, es la función de imprimir.

97
00:05:49,970 --> 00:05:55,490
Se vuelve a poner en pausa la función principal y de nueva cuenta cedemos el control hacia la función

98
00:05:55,490 --> 00:05:56,210
de imprimir.

99
00:05:56,390 --> 00:06:00,860
Se vuelve a crear de nueva cuenta la variable de parámetro, pero esta vez se le asigna el valor de

100
00:06:00,860 --> 00:06:01,550
200.

101
00:06:01,640 --> 00:06:06,470
Recordemos que la variable de parámetro se destruyó al momento en que terminó de ejecutarse la primera

102
00:06:06,470 --> 00:06:07,730
vez la función de imprimir.

103
00:06:07,880 --> 00:06:10,520
Así que esta es la segunda vez que se ejecuta la función de imprimir.

104
00:06:10,520 --> 00:06:12,920
Por lo tanto, la variable de parámetro se vuelve a crear.

105
00:06:12,920 --> 00:06:18,110
Es una variable local al método imprimir y entonces lo que sucede se vuelve a ejecutar nuestra función.

106
00:06:18,560 --> 00:06:23,960
Se imprime ahora el valor de 200 en consola y una vez que termina de ejecutarse la función, se regresa

107
00:06:23,960 --> 00:06:26,030
el control a la función principal.

108
00:06:26,330 --> 00:06:29,420
Así que se reanuda la ejecución del programa principal.

109
00:06:29,630 --> 00:06:34,520
Y si ya es la última línea de código, simplemente termina ya también de ejecutarse el programa principal.

110
00:06:34,820 --> 00:06:39,470
Así que desde el flujo de ejecución de una función podemos observar que en primer lugar la tenemos que

111
00:06:39,470 --> 00:06:40,130
declarar.

112
00:06:40,130 --> 00:06:44,150
Posteriormente, en alguna parte de nuestro programa tenemos que mandar a llamar la función para que

113
00:06:44,150 --> 00:06:49,070
se ejecute y finalmente podemos mandar a llamar esta función tantas veces como la necesitemos.

114
00:06:49,700 --> 00:06:53,510
Bien, vamos a detener hasta aquí este video y vamos a continuar con más características del tema de

115
00:06:53,510 --> 00:06:54,140
funciones.

116
00:06:54,140 --> 00:06:54,710
Saludos.
