C++ Academy · Lección

Representar la ausencia con optional

Evite los punteros nulos

Representar la ausencia con optional es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

El problema de null

Devolver un valor centinela como -1 o un puntero nulo para indicar «ningún valor» es frágil y fácil de usar incorrectamente. std::optional<T> representa explícitamente «un valor o nada». Incluya <optional>.

#include <iostream>
#include <optional>
int main() {
    std::optional<int> maybe = 42;
    std::cout << *maybe << "\n";
}

Un optional vacío

Construir un optional de forma predeterminada o asignarle std::nullopt produce un optional vacío, que no contiene ningún valor.

#include <iostream>
#include <optional>
int main() {
    std::optional<int> empty;
    std::optional<int> also = std::nullopt;
    std::cout << empty.has_value() << " " << also.has_value() << "\n";
}

Comprobar si hay un valor

Llame a has_value() o use directamente el optional en un contexto booleano para comprobar si contiene algo.

#include <iostream>
#include <optional>
int main() {
    std::optional<int> o = 5;
    if (o) std::cout << "has value\n";
    if (o.has_value()) std::cout << "yes\n";
}

Optional como tipo de retorno

Es una opción perfecta para las funciones que pueden no producir un resultado. Devuelva el valor si la operación tiene éxito y std::nullopt si falla.

#include <iostream>
#include <optional>
std::optional<int> half(int n) {
    if (n % 2 == 0) return n / 2;
    return std::nullopt;
}
int main() {
    auto r = half(10);
    if (r) std::cout << *r << "\n";
}

Leer el valor

Use *opt o opt.value() cuando sepa que contiene un valor. Desreferenciar un optional vacío con * es un comportamiento indefinido.

#include <iostream>
#include <optional>
int main() {
    std::optional<std::string_view> name = "Ada";
    if (name) std::cout << *name << "\n";
}

Firmas que se explican por sí mismas

Un tipo de retorno std::optional indica de un vistazo a quien llama que la función puede no producir un resultado; no hacen falta comentarios.

#include <iostream>
#include <optional>
#include <string>
std::optional<std::string> getEnvName(bool present) {
    if (present) return std::string("CONFIG");
    return std::nullopt;
}
int main() { std::cout << getEnvName(true).has_value() << "\n"; }

Restablecer un optional

Llame a reset() para volver a dejar vacío un optional o asígnele std::nullopt.

#include <iostream>
#include <optional>
int main() {
    std::optional<int> o = 99;
    o.reset();
    std::cout << o.has_value() << "\n"; // 0
}

Construir en el lugar

emplace construye directamente el valor contenido dentro del optional y evita una copia adicional.

#include <iostream>
#include <optional>
#include <string>
int main() {
    std::optional<std::string> o;
    o.emplace("built in place");
    std::cout << *o << "\n";
}

Optional frente a puntero

Un puntero sin procesar puede ser nulo, pero no indica nada sobre la propiedad y puede quedar colgante. Un optional posee su valor directamente y señala claramente que «puede estar ausente», sin asignación en el montón.

¿Optional de referencias?

std::optional almacena valores, no referencias. Para hacer referencia opcionalmente a un objeto existente, almacene un puntero o use std::optional<std::reference_wrapper<T>>.

Cuándo recurrir a Optional

Úselo para búsquedas que pueden no encontrar ningún resultado, análisis que pueden fallar o configuraciones que pueden no estar definidas. La siguiente lección trata las formas seguras de acceder al valor contenido.

Comprobación rápida

Compruebe sus conocimientos sobre std::optional.

Resumen

Ha aprendido los conceptos básicos de std::optional:

Representa «un valor o nada» sin centinelas ni valores nulos.
Se deja vacío mediante construcción predeterminada o con std::nullopt.
Se comprueba con has_value() o mediante una prueba booleana.
Es ideal como tipo de retorno para búsquedas que pueden fallar.

Preguntas frecuentes

¿La lección «Representar la ausencia con optional» es gratis?

Sí — el texto completo de «Representar la ausencia con optional» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Representar la ausencia con optional»?

Evite los punteros nulos Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Representar la ausencia con optional»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy