Hola y bienvenido de nuevo.
Me gustaría dar una solución a desafío anterior en esta conferencia.
Una demostración de cómo puede tener punteros como elementos dentro de
la estructura y también Pasar punteros dos funciones
que son estructuras.
Así que abramos el código bloques, cree un nuevo proyecto.
Esto va a ser una consola aplicación, y vamos a nombrar
este ejemplo de punteros de estructura.
Y si te acuerdas del requisitos para esto,
esto era básicamente un tipo de producto estructura que almacena un nombre de artículo, una cantidad,
un precio y una cantidad.
Y el nombre del elemento iba para ser un puntero de carácter.
Ibas a tener un cantidad que básicamente solo multiplica
la cantidad en precio.
Y luego teníamos dos funciones que tomará como parámetros
punteros a una estructura.
Entonces lo primero que somos vamos a
hacer es crear nuestra estructura.
Y mencioné esto antes, pero es bueno
crear la estructura globalmente porque si quieres Úselo en múltiples funciones.
Creando la estructura realmente lo está definiendo.
No estás asignando memoria.
Entonces no hay daño poniéndolo globalmente.
Y suelen entrar el archivo de encabezado de todos modos.
Entonces, para crear una estructura, solo decimos estructura.
Vamos a llamar a este elemento y vamos a tener cuatro elementos.
Vamos a tener un personaje puntero, al que llamaremos
nombre del elemento.
Vamos a tener una cantidad.
Vamos a tener un flotador por el precio, y vamos a tener
una flotación por la cantidad.
Y así es como podemos definir nuestra estructura, bastante básica.
Ahora, dentro de nuestra función principal, desea crear una variable para el tipo de estructura y
también un puntero.
Entonces lo primero que queremos hacer es solo queremos decir elemento de estructura con el
nombre de la estructura y entonces simplemente llamaremos a este elemento.
Y esto es solo creando un puntero extraño.
Esto va a asignar memoria. para las cuatro variables y elementos dentro
de la estructura.
Y entonces queremos crear nuestro puntero ahora, y podemos decir elemento de estructura.
Vamos a decir p item porque solemos nombrar nuestros
punteros con el prefijo p.
Entonces decimos el asterisco, y decimos p item.
Y luego, en la siguiente línea,
solo queremos asignar a nuestro elemento de puntero, nuestro elemento.
Entonces necesitamos usar el dirección de y decimos artículo.
Y aqui tenemos memoria asignado para elementos en nuestra estructura para
nuestro puntero.
No tenemos memoria asignado para nuestro puntero de carácter que
es nuestro nombre de elemento, así que ese sería el siguiente paso.
Ahora puedes preguntar por qué necesitamos para crear la estructura del artículo.
Realmente no lo hacemos.
Podríamos simplemente crear el puntero y el puntero solo creará memoria para ese puntero
de elemento de estructura.
Asignará memoria para el int y flotantes, pero
aún tenemos que hacer la asignación del nombre del elemento.
Solo me gusta hacer esto porque esta suele ser la buena práctica.
Normalmente, lo que harías con la primera estructura del elemento es que
la inicializaría, por lo que tendría alguna inicialización.
Pero no es necesario que hagamos eso.
Entonces, lo primero que queremos hacer es asignar memoria para nuestro nombre de artículo.
Entonces, básicamente podemos usar un operador especial para acceder a elementos si
es un puntero.
Recuerde, para estructuras que son punteros, tiene el guión y luego el símbolo más
grande que puede utilizar para acceder a los elementos.
De lo contrario, tendrías que eliminar la referencia el puntero para acceder a los elementos.
Podríamos hacer algo como esto entre paréntesis.
Podríamos quitar la referencia al puntero, así
que tendríamos que hacer algo como estrella p item y luego usar el punto para acceder a los elementos.
Esto es perfectamente válido hacer algo como esto.
Pero es una especie de sintaxis extra que realmente no necesitas.
Entonces c tiene una sintaxis especial que puede usar siempre que su estructura sea
un puntero si quiere acceder a los elementos.
Básicamente puedes decir el nombre del puntero que es el elemento p y luego use el
guión y luego mayor que.
Y en este caso, queremos asignar memoria para el nombre del artículo.
Así que vamos a asignarle lo que es devuelto de la función malloc.
Recuerde, la función malloc devuelve un puntero vacío.
Entonces tenemos que lanzarlo a una estrella de personaje.
Pero podemos llamar malloc, solo digamos malloc y luego el tamaño de los
bytes que queremos crear.
En este caso, solo diremos 30, y lo multiplicaremos por el tamaño de char, en
caso de que char sea un diferente tamaño en diferentes computadoras.
Y esto va a asignar memoria para el nombre de nuestro artículo.
Necesitamos hacer esto porque el nombre del elemento es un puntero dentro de la estructura.
No tiene memoria asignado para él cuando
lo asigna a otra estructura.
Entonces tenemos que hacer esto.
Ahora lo primero que quieres que hacer
después de haber asignado la memoria es verificar el malloc.
por lo que queremos comprobar si hay nulo aquí.
Solo diremos si p item, if es nulo que diría que es nulo.
De lo contrario, diría que si no, podría simplemente diga que probablemente sea mejor regresar o salir, salga
del programa si no pudieron asignar memoria y podría pasarla
a una negativa.
De lo contrario, queremos leer en un elemento, por lo que queremos crear una función.
La función a la que vamos crear se llama elemento leído.
Pongamos una declaración de función aquí arriba de la estructura.
Solo va a estar leyendo en datos en la estructura que le pasamos.
No devolverá ningún dato.
Entonces podemos decir leer artículo y se necesita una estructura, que será un
puntero.
Entonces es un elemento de estructura, asterisco I.
Ahora podríamos hacer de esto una constante así que los valores cambian,
pero estamos cambiando los valores.
Pero podríamos decir estructura constante, la los valores no podrían cambiar para
ese puntero al que apunta.
Si hiciéramos la constante después el asterisco, eso diría que la dirección no puede cambiar
o correcta antes del asterisco algo así después
del nombre.
Eso diría que la dirección no puede cambiar, pero
eso es redundante porque estamos pasando por valor de copia.
Tenemos nuestro artículo leído.
Y mientras estoy aqui arriba podria también hago mi artículo de impresión.
Esa va a ser la función declaración, prototipo de función.
Aquí va a ser muy similar, también tome un puntero.
Puedes tener un espacio si quieres después del asterisco o no?
Ahora podemos definir nuestra lectura artículo debajo de nuestro método principal.
Y esto se va a leer en valores del artículo y
luego calcular la cantidad total.
Entonces podemos decir vacío leer artículo, tenga nuestro puntero.
Y aquí adentro, solo queremos para usar algunos scanfs realmente.
Vamos a imprimir algunos mensajes para decirle al usuario que ingrese información.
Entonces vamos a decir entrar nombre del producto, y luego lo vamos a
leer.
Entonces vamos a decir scanf, y tenemos un puntero a una estructura, por lo que podemos acceder
a ella usando el guión luego mayor que.
Queremos leer para scanf, el El nombre del producto es un búfer de caracteres.
Así que queremos decir porcentajes y luego vamos a decir yo, lo guardaremos en el
nombre del artículo.
Y podríamos volver y usar el intellisense simplemente vaya al nombre del elemento.
No tenemos que usar el dirección del operador porque es
un puntero de carácter.
Luego queremos imprimir y obtener el precio,
probablemente quiera agregar algunos avances de línea aquí, ingrese el precio.
Vamos a almacenar eso en la estructura.
Sin embargo, de nuevo, el precio es flotante.
Así que voy a decir porcentaje f, pero también vamos a acceder a él porque es un puntero, todavía
queremos use el guión luego mayor que.
Excepto que esta vez, vamos a decir precio, y necesitamos obtener la dirección, así que vamos a ponga un
signo comercial delante de él porque el precio no
es un indicador.
Y luego haremos el lo mismo por la cantidad.
Entonces la cantidad es un número entero.
Entonces podemos decir el porcentaje d, todavía necesitamos para obtener la dirección
del mismo, pero queremos almacenarlo en un elemento diferente, queremos almacenarlo en la cantidad.
Ahora que hemos almacenado o pedido que el usuario ingrese
tres elementos de información, ahora podemos en realidad calcula la cantidad, almacena algo
en la cantidad.
La cantidad es solo la cantidad multiplicada por el precio.
Así que todavía queremos acceder al estructura usando nuestra sintaxis, queremos
convertirla, queremos firmar la cantidad multiplicada por el precio.
Y esa es la función de lectura de elementos.
Toma un puntero de estructura.
Y entonces cuando modificamos este puntero dentro del elemento leído, se
modificará fuera de la función.
Entonces, sea cual sea la estructura pasar a esta función,
se modificará.
Va a almacenar todos los artículos, el nombre del artículo, precio
y cantidad y monto.
Entonces eso se lee en los datos.
En este punto, querrás prueba y probablemente desee compilar y
probar antes de esto.
Pero ahora podemos llamar al elemento leído en nuestro método principal y pasarlo
a nuestra estructura que creamos.
Entonces podemos decir leer elemento, y solo podemos decir p item.
No tenemos que pasar en el address porque es un puntero, por
lo que simplemente pasamos nuestra estructura.
Y luego lo siguiente que lo que podemos hacer es imprimirlo.
Y lo que esto te mostrará es que los datos se guardan, el elemento p
se está modificando dentro de la función y se guarda fuera de la función, la
función principal en realidad ha guardado esos valores.
Entonces podemos decir que el elemento de impresión pasa en el puntero nuevamente, y luego podemos definir la función del
elemento de impresión.
El elemento de impresión es bastante básico.
No devuelve nada, entonces decimos vacío y decimos que el
elemento de impresión lleva un puntero.
Así que solo decimos estructura elemento estrella Yo, como quieras llamarlo.
Y luego imprimimos los datos para la estructura que se pasó.
Entonces haríamos algo como printf name percent s, I nombre del artículo, I precio,
I cantidad y I cantidad y luego formateamos los datos.
¿Qué es lo último que tenemos?
hacer en la principal después de que imprimimos los datos, el función libre realmente importante.
Tenemos que llamar gratis porque queremos liberar la memoria que asignamos para
el nombre del elemento.
Entonces podemos decir artículo p gratis y luego acceda al nombre del elemento.
No queremos liberar a todo estructura porque
toda la estructura se eliminará en el apilar cuando la función regresa.
Solo queremos liberar lo que mallocamos.
Solo mallocemos para el artículo name así que lo liberamos, y
luego regresamos del main.
Así que sigamos adelante y intenta construir esto.
Y tenemos un error.
Veamos que dice estructura elemento estrella.
Entonces tuvimos un error donde las funciones se definieron por encima de
la estructura.
Pero la función de tomar un parámetro como un tipo de estructura.
Entonces tenemos que tener la estructura definido arriba donde lo estamos usando.
Entonces muevo las funciones hasta las líneas 12 y 13.
Ahora podemos compilar.
Sigamos adelante y ejecutemos esto.
Y veamos qué obtenemos aquí.
Tenemos un error más.
Tienes que asegurarte marque el elemento p para nulo.
Si solo dice si p artículo para cierto, siempre será cierto.
Entonces puedes marcar para decir no es cierto con el símbolo no, lo
que significa que no es nulo o usted puede comprobar para ver si es nulo.
Así que acabo de agregar el nulo allí.
Así que ahora lo ejecutamos, nosotros Debería estar listo.
Podemos ingresar el nombre del producto.
Diremos serial, y lo haremos digamos que el precio es 1. 99.
Y diremos que tenemos cinco de esos.
Y ahora lo imprimimos y decimos dólar de serie 99.
5, la cantidad total es 9. 95.
El precio aunque no me gusta cómo se imprime el precio.
Así que arreglemos eso.
En nuestro artículo de impresión, solo podemos decir por price dor 2 f floats,
ahora nos veremos un poco mejor y lo ejecutamos.
Conseguiremos un poco un poco de mejor formato.
Cuatro de ellos y ahora se ve un poco mejor
y todo está listo.
Así que de nuevo, programa básico usando estructuras y punteros.
Creamos la estructura en la parte superior.
Tenemos un miembro que contiene un puntero, es muy
eficaz hacerlo porque podemos simplemente copie y direcciones en lugar de
matrices de caracteres.
Tenemos nuestras dos declaraciones de funciones, leer elemento imprimir elemento
que toma punteros destruye.
Y luego creamos el puntero y asignarlo a una estructura regular
dentro de nuestro main.
Asignamos memoria en la línea 22.
Nos aseguramos de que la memoria sea asignado con éxito si no lo
fue, salimos del programa.
Y luego llamamos a nuestros dos funciones que
llevan punteros a estructuras, pásalas.
Y luego, por último, pero no menos importante, liberamos la memoria y luego
salimos del programa.
Y las funciones son muy claro.
Toma ese puntero.
Accede al puntero usando el guión entonces mayor que.
Y obtienes la dirección de es para scanfs que no
tienen punteros como elementos.
Y eso es básicamente todo.
Guardaré este programa le echas un vistazo.
Hazme saber si tienes alguna pregunta. Gracias.