Sesión 27 · Estructuras: definición, inicialización y operaciones

21 de noviembre de 2026⏱ 6 min de lecturaProf. profesor

Semana 14 · Unidad 4: Punteros, Estructuras y Archivos

Objetivo: Agrupar datos de distintos tipos en una estructura.

Objetivo y ruta de la sesión

Objetivo de aprendizaje

Agrupar datos de distintos tipos en una estructura.

En esta clase trabajaremos

Estructuras; definición, inicialización y operaciones.

Ruta de la sesión (120 min)

10′ · Activación de conocimientos

35′ · Teoría y ejemplos guiados

55′ · Práctica y ejercicios en clase

10′ · Cierre y explicación del deber

Activación: pregunta de entrada

PREGUNTA DE ENTRADA

Un estudiante tiene nombre, código, carrera, promedio y edad. ¿Cómo guardarías todos esos datos de distinto tipo juntos, como una sola «ficha»?

Para pensar y compartir

1. Escribe tu respuesta en 1 minuto.

2. Compárala con la de tu compañero.

3. Compartan una idea con la clase.

Estructuras (struct): agrupar datos relacionados

Una estructura agrupa variables de distintos tipos bajo un solo nombre.

Cada componente se llama campo o miembro.

Se accede a un campo con el operador punto: est.edad.

Permite modelar «registros»: un estudiante, un producto, un empleado.

struct Estudiante {
    int   codigo;
    string nombre;
    float promedio;
    int   edad;
};

Estudiante e;

Declarar, inicializar y usar una struct

struct Producto {
    int   codigo;
    string nombre;
    float precio;
};

int main()
{
    Producto p = {101, "Cuaderno", 2.50};

    p.precio = p.precio * 1.10;
    cout << p.codigo << " - " << p.nombre << " - $"
        << fixed << setprecision(2) << p.precio << endl;
    return 0;
}

101 - Cuaderno - $2.75

Qué observar

  • La definición va fuera de main.
  • Se inicializa con llaves, en orden.
  • p.campo para leer o modificar.
  • Un string se imprime directamente con cout.

Leer una estructura del teclado

Estudiante e;

cout << "Codigo: ";
cin >> e.codigo;
cout << "Nombre: ";
cin >> e.nombre;
cout << "Promedio: ";
cin >> e.promedio;

cout << e.codigo << " " << e.nombre << " "
    << fixed << setprecision(2) << e.promedio << endl;
Codigo: 12
Nombre: Ana
Promedio: 8.7
12 Ana 8.70

Qué observar

  • cin >> e.nombre lee una palabra (hasta el espacio).
  • Para nombres con espacios: getline(cin, e.nombre).
  • Los campos numéricos se leen igual con cin >>.
  • En C++ no se usa & con cin.

Estructuras en funciones

En C++ el nombre de la estructura ya es un tipo: no hace falta typedef.

Por valor: la función recibe una copia y no modifica el original.

Por puntero: se usa -> (p->campo equivale a (*p).campo).

Por referencia (&): se usa el punto como siempre y modifica el original.

struct Alumno {
    int codigo;
    float nota;
};

void ver(Alumno a) {
    cout << a.codigo << " " << a.nota;
}
void subir(Alumno &a) {
    a.nota += 1;
}
void subirP(Alumno *a) {
    a->nota += 1;
}

Ejercicio: Registro de un estudiante

EN CLASE · Básico

Define una estructura Estudiante con al menos 5 campos (codigo, nombre, carrera, edad, promedio). Ingresa 3 estudiantes y muestra sus datos.

Codigo 1 / Ana / Computacion / 19 / 8.9
…

Pistas

  • Tres variables o un for con un arreglo (siguiente sesión).
  • Cadenas: string nombre;
  • Muestra con cout; decimales con setprecision(2).

Solución: Registro de un estudiante

struct Est {
    int codigo; string nombre, carrera;
    int edad; float promedio;
};

void leer(Est *e)
{
    cin >> e->codigo >> e->nombre >> e->carrera;
    cin >> e->edad >> e->promedio;
}

void mostrar(Est e)
{
    cout << e.codigo << " " << e.nombre << " "
        << e.carrera << " " << e.edad << " "
        << fixed << setprecision(2) << e.promedio << endl;
}

/* main: Est a, b, c; leer(&a); ... mostrar(a); */

Revisión

  • Funciones leer y mostrar reutilizables.
  • Estructura pasada por dirección para leer.
  • El siguiente paso: arreglo de estructuras.

Ejercicio: Función que modifica un registro

EN CLASE · Intermedio

Con struct Producto {codigo, nombre, precio, stock}, escribe void vender(Producto *p, int cant) que reste del stock si alcanza, o avise «Stock insuficiente».

stock=10, vender 4 → 6
stock=6, vender 9 → Stock insuficiente

Pistas

  • Parámetro puntero a struct.
  • Usa p->stock.
  • Valida cant <= p->stock.

Solución: Función que modifica un registro

struct Producto {
    int codigo; string nombre;
    float precio; int stock;
};

void vender(Producto *p, int cant)
{
    if (cant <= p->stock)
        p->stock -= cant;
    else
        cout << "Stock insuficiente" << endl;
}

Revisión

  • -> accede a un campo mediante puntero.
  • El registro original queda modificado.
  • La validación evita stock negativo.

Ejercicio: Comparar dos estructuras

EN CLASE · Intermedio

Define struct Punto {float x, y;}. Lee dos puntos y calcula la distancia entre ellos (necesitarás #include <math.h> y sqrt).

(0,0) y (3,4) → distancia 5.00

Pistas

  • d = sqrt((x2-x1)² + (y2-y1)²)
  • float dx = b.x – a.x;
  • Usa #include <cmath> para sqrt.

Solución: Comparar dos estructuras

#include <cmath>

struct Punto { float x, y; };

float distancia(Punto a, Punto b)
{
    float dx = b.x - a.x, dy = b.y - a.y;
    return sqrt(dx * dx + dy * dy);
}

/* main */
Punto p = {0, 0}, q = {3, 4};
cout << fixed << setprecision(2) << distancia(p, q)
    << endl;

Revisión

  • La estructura se pasa por valor: solo se lee.
  • dx² + dy² = 9 + 16 = 25 → 5.
  • Estructuras simples modelan conceptos matemáticos.

Verificación rápida (5 min)

1. Una estructura permite agrupar datos…

  • A) Solo enteros
  • B) De distintos tipos
  • C) Solo cadenas
  • D) Solo del mismo tipo

2. ¿Cómo se accede a un campo de una variable e?

  • A) e->campo (siempre)
  • B) e.campo
  • C) e[campo]
  • D) campo(e)

3. Para que una función modifique una estructura, se pasa…

  • A) Una copia
  • B) Su dirección (puntero)
  • C) Un float
  • D) Nada

Respuestas y justificación

Respuesta B · 1. De distintos tipos A diferencia de un arreglo, los campos pueden ser de tipos distintos.

Respuesta B · 2. e.campo El operador punto; -> se usa con punteros.

Respuesta B · 3. Su dirección (puntero) Así trabaja sobre la original (con ->).

Actividad y deber

ACTIVIDAD EN CLASE

struct; declaración de variables; operador punto; lectura y visualización de campos; estructuras en funciones.

DEBER

Tarea 27 – Registro con struct

Definir una estructura Estudiante o Producto con al menos 5 campos; ingresar y mostrar 3 registros.

Entregable: Archivo .cpp.

Qué nos llevamos hoy

  1. struct agrupa campos de distintos tipos en un registro.
  2. Acceso con punto (e.campo) o con flecha (p->campo).
  3. typedef simplifica los nombres.
  4. Se pasan por dirección para modificarlas.

Pregunta de cierre: ¿qué aprendí hoy que antes no podía explicar o programar?

Bitly

¡Buen trabajo! Llegaste al final de esta clase. Repasa los ejemplos, haz la tarea y, si tienes dudas, déjalas en los comentarios. — Bitly

💬 Preguntas y comentarios

¿Algo no quedó claro? Pregunta aquí y te respondo.

Deja tu pregunta