Hola y bienvenido. Estamos en una nueva sección.
Hablaremos de estructuras.
Este es un nuevo concepto en c que le
permite agrupar elementos juntos, similar a la matriz pero más poderoso.
Quiero hablar sobre qué es una estructura, cómo se puede crear y cómo se
puede utilizar una estructura.
Entonces, las estructuras en c proporcionan otra herramienta para agrupar elementos.
Nuevamente, mencioné que son similares a una matriz, pero en realidad son un poco más potentes.
Si está familiarizado con la
programación orientada a objetos, si programa en java
o c-plus plus o cualquier lenguaje orientado a objetos, se considera
como un objeto, pero solo con miembros de datos, sin comportamiento real, sin métodos.
Por lo tanto, es
un concepto poderoso que usará en muchos programas de
c que desarrolle porque puede agrupar diferentes elementos en
un solo nombre y estos pueden representar esencialmente atributos de datos.
Por ejemplo, digamos que desea almacenar una fecha dentro de un programa.
Una fecha generalmente consta de tres variables: mes, día y año.
Crearías esas tres variables para almacenar esos datos.
Por ejemplo, diría que int mes es igual a 9 días es igual a 25 años
es igual a 2015.
Suponga que su programa también necesita almacenar la fecha de compra de un artículo en particular.
Bueno, probablemente tendrías que crear tres variables más para cada
fecha que uses en tu programa. Entonces puedes ver cómo esto
puede volverse muy repetitivo y terminas creando muchas variables.
Pero lo que debe notar es que estas variables están relacionadas lógicamente. Son todas citas.
Realmente deberían agruparse.
Casi deberían ser su propio tipo de datos y luego debería poder crearlos y
acceder a los diferentes elementos.
No debería tener que crear tres variables independientes para cada fecha.
Entonces, nuevamente, aquí es donde entra en relación con los objetos
y una clase que tiene tres atributos de datos.
Por lo tanto, sería mucho mejor si pudiera agrupar de alguna manera estos conjuntos de tres variables.
Y esto es precisamente lo que hace el elemento estructura y c.
Le permite agrupar estos diferentes elementos junto con un nombre particular.
Luego puede crear diferentes variables con ese nombre y
acceder a los elementos en ese
nombre, los diferentes atributos de datos, en realidad se llaman miembros.
Entonces, ¿cómo se crea una estructura en c.
Es muy muy simple. La declaración de estructura describe cómo se arma una estructura.
Qué elementos hay dentro de la estructura.
Y normalmente nos referimos a estos elementos como miembros.
Como primero tienes que definir la estructura o declarar la estructura,
describe qué hay dentro de la estructura.
Y entonces puedes hacerlo con la palabra clave struct.
La palabra clave struct le permite definir una
colección de variables de varios tipos denominada estructura que puede tratar como una sola unidad.
Muy, muy poderoso.
Entonces, al usar esta palabra clave de estructura, todo lo que tiene que hacer es proporcionar un
nombre, que generalmente se conoce como el nombre de la etiqueta. En este ejemplo, tenemos un nombre de etiqueta de fecha.
Pero ves la estructura de la palabra clave, esa es la palabra clave que le
dice al compilador de c que esta será una función específica.
Esto puede tener una funcionalidad específica que le permite agrupar elementos.
Así que struct es la palabra clave seguida del nombre
de la etiqueta y luego tienes la llave izquierda
y la llave derecha seguida de un punto y coma para terminar.
Y luego, dentro, puede definir cualquier tipo de variable que desee, incluso puede poner punteros allí.
Y esos se denominan miembros de la estructura.
Entonces, esta es una declaración nuevamente, define una estructura de fecha
que el compilador de c comprenderá.
Le dice al compilador de c qué va a contener la
estructura de estado, tres elementos:
mes, día y año. No hay asignación de memoria para esta declaración.
Nuevamente, lo que está diciendo es que esta es una estructura que existe.
No he empezado a usarlo todavía. Solo dije que así es como se va a definir.
Esta será la estructura de fechas y en esto consiste.
Los nombres de las variables dentro de la estructura de la fecha, el mes, el
día y el año, se denominan miembros o campos.
Los miembros de la estructura aparecen entre las llaves que siguen a
la fecha del nombre de la etiqueta de estructura, por lo que la fecha del nombre de la etiqueta.
Sintaxis muy, muy simple para agrupar estos elementos dentro de un solo nombre que es fecha.
Y nota que es diferente de una matriz porque no
hay índices, en realidad no está especificando un tamaño.
No es exactamente el mismo tipo de datos.
Puede tener diferentes tipos de datos y puede tener muchos diferentes.
Entonces, ¿cómo utilizaría esta estructura?
Bueno, la definición de fecha define un nuevo tipo en el lenguaje.
Realmente puede pensar en él como otro tipo, como un int, un doble o un flotante.
Excepto este tipo que definiste, casi puedes pensar en él como una enumeración.
Excepto que una enumeración solo tiene un valor.
Esta estructura de fecha puede contener tres valores, pero es otro tipo de datos.
Ahora se puede declarar que las variables son de tipo estructura hasta la fecha.
Así que eso es exactamente lo que harías.
Podría crear una nueva variable llamada hoy y será
un tipo de estructura de tipo fecha.
Y hoy esencialmente va a poder contener tres valores.
Y luego, si necesita declarar más
fechas, puede crear más variables del mismo tipo.
Por lo tanto, ya no necesita tener tres variables separadas para una fecha de
compra, tres variables separadas para la
fecha actual, tres variables separadas para una fecha de facturación.
Puede tener una variable
o dos variables de diferentes instancias de esa estructura real.
Una vez más, es de esperar que se dé cuenta de lo poderoso que puede ser esto.
Entonces, esta declaración anterior debe ser de tipo estructura fecha, fecha
de compra.
La memoria ahora está asignada porque declaró que la variable
Memory está asignada para esta estructura.
La memoria se asigna para los tres valores enteros o los tres
miembros de cada variable, por
lo que la memoria se asignará.
Y también la razón por la que se asignará es porque no hay punteros allí.
Si hubiera punteros en esa estructura, tendría que asignar memoria para ese puntero.
Pero dado que esta estructura de fecha de hoy es una estructura
muy simple, estoy comenzando lentamente, contiene tres entradas, esos miembros se asignan automáticamente para usted.
Pero asegúrese de comprender esta distinción de la diapositiva anterior y esta diapositiva actual.
Existe una diferencia entre definir una estructura y declarar las variables de ese
tipo de estructura en particular.
De nuevo, la estructura financiera le está diciendo al compilador de c: aquí hay
una estructura y esto: estos son los datos que están dentro de ella.
Pero en realidad declarar una variable de ese tipo de estructura en particular
es decir que voy a comenzar a usar esa estructura.
Ahora tengo memoria asignada para los tres elementos de nuestro ejemplo
y puedo acceder a esos elementos y configurarlos.
Entonces, ¿cómo accedes a los miembros en una estructura?
Entonces, ahora que sabe cómo definir una estructura
y ahora sabe cómo declarar variables de
estructura, ahora necesita poder entender cómo hacer referencia a esos miembros de struct.
Tienes que acceder a ellos. Si no pudiera acceder a ellos para ver los valores o establecer valores, sería inútil.
Entonces, un nombre de variable de estructura no es un puntero.
Entonces necesitas una sintaxis especial para acceder a los miembros.
Porque los punteros generalmente contienen solo el valor de
una dirección.
Y si no es un puntero, necesitará una sintaxis especial.
Puede hacer referencia a un miembro de una estructura escribiendo el nombre de la variable seguido de un punto.
Suele llamarse como el operador de punto.
Y luego, después de ese período de
operador de puntos, sigue el nombre de la variable miembro dentro de esa estructura.
El período entre el nombre de la
variable de estructura y el nombre del miembro se denomina operador de
selección de miembros, también denominado operador de puntos.
No se permiten espacios entre el nombre de la variable, el punto y el nombre del miembro.
Para establecer el valor del día en la variable de hoy en
25, simplemente haría algo como esto. El nombre de la variable
que es hoy, y luego diría punto, sin espacios entre ambos lados.
Y luego especificaría el nombre del elemento dentro de la definición de estructura,
que es día.
Y luego lo asignaría como lo asigno a cualquier otro número entero.
Usaría el operador de asignación igual,
una constante literal aquí y el punto y coma.
Muy, muy simple. Si quiero asignar
el año, diría hoy. año y yo diría igual 2015 por ejemplo.
Y cuando quiero acceder a los valores de los miembros.
Por ejemplo, si quisiera acceder al valor de miembro del mes para ver si es igual a 12,
seguiría usando esa sintaxis de puntos, ese operador de selección de miembros.
Por tanto, puede utilizar el operador de selección de miembros para acceder a los valores de los miembros.
Y cuando accede a
esas variables miembro, puede usarlas como usa otras variables.
Puede usarlos en operaciones aritméticas si son enteros.
Seguiría las reglas de ese tipo de datos.
Entonces, en este caso, podemos comparar eso en 12 simplemente usando
los iguales es igual dentro de una declaración if.
Y luego, por ejemplo, si fuera igual a 12, podríamos decir que el próximo mes es igual a 1.
Esa puede ser una variable local que le asignaríamos.
Así que veamos un ejemplo. Aquí estamos definiendo una estructura llamada fecha.
Tenemos tres elementos, enteros: mes, día y año.
Sabemos que lo estamos definiendo porque tenemos la palabra clave struct y tenemos esas llaves.
Y luego observe también que la llave derecha tiene un punto y coma para finalizar la definición.
En este punto, no se asigna memoria para esta estructura.
En la siguiente línea, declaramos una variable de ese tipo,
por lo que ahora estamos asignando memoria para un nombre de variable
que contiene esencialmente tres elementos: mes, día y año de tipo int.
Podemos asignar datos a esos tres elementos dentro de esa estructura hoy
con solo usar ese acceso de miembro de punto.
Así que hoy. mes es igual a nueve, hoy. día es igual a 25 y hoy. año 2015.
Si luego quisiéramos imprimirlo o acceder a esos datos, accederíamos a ellos de la misma manera
después de haberlos asignado. Solo usaríamos esa selección de miembros: hoy. mes, hoy. día
a día. año. Y nuevamente, podemos realizar operaciones aritméticas en él porque es un int.
Usaríamos el porcentaje d o, si queremos formatearlo en
2, podríamos decir porcentaje 2I o porcentaje 2D.
Así que esta es una sintaxis bastante sencilla,
muy fácil de crear y definir estructuras y luego usarlas y luego
acceder a ellas usando el operador de selección de miembros punto.
¿Qué hay de estructuras y expresiones?
Bueno, acabas de ver que pude acceder a datos y usar una expresión aritmética y
no es diferente.
Cuando se trata de la evaluación de la
expresión, los miembros de la estructura siguen las mismas reglas que las variables ordinarias.
Si tiene miembros dentro de esa estructura que son enteros, puede hacer
las mismas reglas que cualquier otro entero.
Puede aplicar sumas, restas, etc. Si es un búfer de caracteres, solo puede seguir
las reglas de los búferes de caracteres. ¿Puedes agregar y menos búferes de
caracteres, cosas así, generalmente no?
Entonces, flotantes, dobles, todos los diferentes tipos
de datos, simplemente seguiría esas mismas reglas cuando use esos miembros dentro de expresiones.
Así que aquí tienes un ejemplo.
Digo hoy. años divididos por cien más uno.
Perfectamente válido porque year es un int,
no es diferente de usar una variable regular de tipo int.
Simplemente acceda a él de manera diferente utilizando ese operador de selección de miembros.
Ahora hay variantes. Hay diferentes formas de definir las estructuras.
Lo bueno de c es su flexibilidad y c le
permite definir una estructura de muchas formas diferentes. Por lo tanto, puede
ver una sintaxis diferente cuando define una estructura.
El primer ejemplo que te mostré es realmente el que debes seguir. Siempre debe tener un nombre de
etiqueta, y debe definir la estructura en un lugar de su código y luego
declarar sus variables en otro. Pero como
está, es muy flexible. De hecho, puede definir estructuras y declarar variables en la misma línea.
Y también puede definir estructuras anónimas o estructuras sin nombre.
Entonces hay mucha flexibilidad. Es válido declarar que una
variable es parte de una estructura particular al mismo tiempo que estás definiendo la estructura.
Puede poner el nombre de la variable en la parte inferior. Te mostraré cómo hacer eso.
Incluya el nombre o los nombres de la variable antes del punto y coma final de la definición de estructura.
Y también puede asignar e inicializar valores a esas variables de la
manera normal que asigna cualquier variable. Así que miremos eso.
Una variación de definir una estructura haciéndola al mismo tiempo que la estás definiendo,
puedes declarar una variable. Entonces, en este caso,
definimos nuestra fecha de estructura, pero también creamos una variable llamada hoy.
Porque al final de la llave derecha, ese es el nombre antes del punto y coma,
es decir, tanto la creación de la variable de tipo fecha estructura como la definición de la estructura fecha.
Entonces, en esta instancia anterior, está creando una
variable de la estructura.
Nos referimos a eso también como una instancia de la estructura. Se llama hoy.
Se declara al mismo tiempo que se define la estructura.
Así que hoy es una variable de tipo fecha, lo hicimos todo en uno.
Y en realidad, justo después de hacer
el día de hoy, podría inicializar esas variables usando
los corchetes y luego diciendo
que el mes es igual a cinco, el día es igual y así
sucesivamente, al igual que inicializa cualquier otro número entero.
Ahora, de nuevo, otra forma de crear una estructura es
crear una estructura sin nombre. Esto es un poco más limitado porque
no se puede hacer mucho con él.
Pero no es necesario que proporcione un nombre de etiqueta.
Recuerde, el nombre de la etiqueta está en la parte superior, justo después de la palabra clave struct.
En los ejemplos anteriores, el nombre de la etiqueta era fecha.
Pero no es necesario que proporcione esa fecha.
Si todas las variables de un tipo de estructura particular se definen cuando se define la estructura,
entonces se puede omitir el nombre.
Y lo que esto realmente significa es que solo usará la estructura
una vez y solo una vez.
Entonces, podríamos decir struct int
day, int year, int month y luego declarar
la variable en la misma cosa.
Pero notará que no hay un nombre de etiqueta después de la palabra clave struct.
Esta es solo una estructura. Vamos a usar una vez,
así que creamos la variable hoy y nunca la volveremos a usar.
Y esa es realmente la desventaja y la limitación.
Realmente nunca querrá hacer esto a menos que tenga algún tipo de estructura local que use una vez.
Pero no puede definir más instancias de esto si define la
estructura de esta manera como
una estructura sin nombre, una estructura sin nombre.
Todas las variables de este tipo de estructura que desea que su programa se definan en una declaración.
Podrías crear más de una variable, podrías hacer la coma de hoy
y luego otra variable para poder crear múltiples variables.
Puede inicializar varias variables.
Pero esta forma es un poco limitada porque después de
esa declaración de variable en la parte inferior, no puede crear más variables.
Entonces, hay tres formas de definir diferentes estructuras.
Una forma es definir la estructura con un nombre de
etiqueta y no crear la variable. La variable se crea en una instancia separada cuando se asigna la memoria.
Otra forma es crear la variable y la estructura
y al mismo tiempo donde tendrías un nombre
de etiqueta y eso te permitiría
crear otras instancias u otras variables de ese tipo de estructura más adelante en
tu programa o esta tercera opción donde podrías crear una estructura sin
nombre sin nombre y
solo la variable en la parte inferior. Y nuevamente, puede inicializar todos estos
siempre que cree las variables simplemente usando las llaves y así sucesivamente.
Entonces ahora inicializando estructuras.
La inicialización de estructuras es muy similar a la inicialización de matrices.
Los elementos se enumeran dentro de un par de llaves
con cada elemento separado por una coma.
Realmente no hay cosas nuevas que aprender aquí.
Los valores iniciales enumerados dentro de las llaves deben ser expresiones constantes. No
puede usar variables, se parece simplemente a una matriz.
Aquí estamos creando una variable de hoy de tipo
struct date, y estamos diciendo que el primer miembro es igual a
siete, el segundo es dos y el tercero es 2015, que corresponde al día del
mes en el año porque ese es el orden
de cómo se definieron en la estructura.
Así que, al igual que en la inicialización de
una matriz, es posible que se enumeren menos valores de los que contiene la estructura.
No tiene que proporcionar los tres, solo puede
proporcionar dos y eso inicializaría el mes y el día
y no inicializaría el año.
Entonces esto fijaría la fecha. uno. mes hasta
la fecha 12 1. día a 10, pero no da ningún valor inicial hasta la fecha. año.
También puede especificar los nombres de los miembros en la lista de inicialización de esta
manera, no es necesario que tenga ningún orden.
Puede ponerlos en el orden que desee y no depende de eso.
Entonces podrías hacer algo como. miembro es igual a
valor y fecha de estructura, fecha uno. Se podría decir que el mes de los puntos es igual a 12.
Entonces, la sintaxis inicial de esto es colocar el miembro dentro de las
llaves con el punto y luego simplemente asignar el valor, el mes del punto es igual a
12 y la fecha del punto es igual a 10.
Necesitas ese punto. Ese punto es importante, así que no te olvides de ese punto.
No necesita la instancia antes del punto.
Así que esto solo va a establecer el miembro de año
de la variable de estructura de fecha hoy en 2015
en el siguiente ejemplo.
Así que aquí solo decimos porque recuerde que puede omitir algunas
de las otras variables miembro. Y en este caso, estamos admitiendo el mes
del día, por lo que solo vamos a establecer el año en 2015.
En el caso anterior, en realidad omitimos el año
y simplemente establecimos el mes y la fecha en 12 y 10 respectivamente.
También podemos hacer asignaciones con literales compuestos.
Bueno, ¿qué es eso exactamente? Es un literal compuesto.
Puede asignar uno o más valores a una estructura en una sola
declaración utilizando lo que se conoce como literal compuesto.
Creo que esto solo podría estar en C11.
Pero aquí tenemos hoy,
supongamos que creamos una variable de estructura de fecha de
hoy, y luego estamos poniendo entre paréntesis la fecha de estructura.
Y dentro de las llaves, estamos diciendo 9 coma 25 coma 2015.
Y este es un literal compuesto.
Esta declaración puede aparecer en cualquier parte del programa.
Entonces, en lugar de inicializar o asignar valores usando el miembro punto, puede
poner esto en cualquier lugar del programa después de haber inicializado la
estructura de hoy. No es una declaración de declaración.
Esta es una asignación literal compuesta.
El operador typecast se usa para decirle al compilador el tipo de expresión.
Entonces, necesitas esas cosas entre paréntesis que son una fecha de estructura y conversión.
La lista de valores sigue al
elenco y debe asignarse a los miembros de la estructura en ese orden, depende del orden.
Por lo tanto, aparece de la misma manera que si estuviera inicializando una variable de estructura.
Nuevamente, la ventaja de esto
es que no tiene que asignar cada variable miembro individualmente en líneas separadas.
Puede hacerlo todo en una línea y decir que está bien, este es el nuevo
valor para esta variable hoy.
También puede especificar valores usando la notación de miembro de punto como mencioné.
Solo tendría que hacerlo en una línea como esta
o en líneas separadas. Y de esta manera, se parece a la inicialización,
pero todavía estás haciendo los literales compuestos.
La ventaja de utilizar este enfoque es que los argumentos pueden aparecer
en cualquier orden, como antes.
Nuevamente, la clave y la diferencia de estas asignaciones es que
no está sucediendo en la inicialización, lo
está haciendo en otro lugar del programa para asignar nuevos valores a ese tipo.
Así que hay mucha buena información en esta conferencia.
Hablamos sobre estructuras y lo poderosas que son y cómo podemos agrupar
diferentes elementos o diferentes variables en un solo nombre.
Definimos esa estructura. Hay varias formas de definir una estructura.
Y luego también necesitamos declarar una variable.
Una vez que tenemos esa variable, podemos
acceder, asignar datos a esa estructura usando el operador de selección de miembro de punto.
Y luego también discutimos algunas de las diferentes notaciones
y diferentes formas de hacer las cosas, así como la inicialización.
Vamos a utilizar bastante las estructuras.
Tendré un par de desafíos que te ayudarán a familiarizarte con esta sintaxis.
Pero este es solo el comienzo de la estructura. También tenemos que
hablar sobre estructuras anidadas, cómo se pueden usar punteros y
estructuras y cosas por el estilo.
Así que buena suerte, esta será una sección divertida y emocionante. Gracias.