La función «std::Optional» se proporciona en C++17. «std::Optional» permite la representación con seguridad de tipos de valores opcionales o selecciones con valores. La clase de plantilla denominada «std::Optional» contiene un valor opcional que puede contener o no un valor válido. Es una alternativa más segura para representar valores nulos u opcionales que los indicadores sin formato u otras técnicas. «std::Optional» minimiza la posibilidad de errores de desreferencia de puntero nulo al requerir que el usuario verifique explícitamente que el valor existe antes de recuperarlo.
Ejemplo 1:
Los archivos de encabezado «opcionales» y «iostream» se importan en este código. Debemos importar estos archivos de encabezado para que podamos acceder fácilmente a las funciones definidas en ellos. Después de eso, incluimos «namespace std» para no tener que escribirlo usando funciones como «std::Optional» y «std::cout» respectivamente. Usamos «espacio de nombres estándar» aquí. Entonces, ahora, en lugar de escribir «std», ponemos «opcional» o «cout».
Luego llamamos a main() y ponemos «opcional» y lo convertimos en «int» y declaramos «myNum». Esta es la sintaxis para declarar variables «std::Optional». Luego inicializamos otra variable llamada «valor» y asignamos un valor a la variable «myNum» usando la función value_or(). Estamos pasando «99» en esta función, por lo que si no hay ningún valor, asigna «99» a la variable «muNum» y lo almacena en la variable «valor». Luego colocamos «cout» debajo, lo que ayuda a mostrar el valor que asignamos a la variable que se encuentra encima.
Código 1:
#incluir
Usar espacio de nombres estándar;
entero principal() {
Electivoentero> mi número;
entero valor = mi número.valor o(99);
kut «El valor de myNum es:» valor endel;
devolver ;
}
Producción:
Aquí podemos notar que se muestra «99», lo que significa que el valor anterior no existe y el valor que agregamos ha sido asignado a la variable.
Ejemplo 2:
Primero incluimos el archivo de encabezado y colocamos «namespace std». Ahora, debajo de esto, declaramos la función «std::Optional», que es «divideFunc()». «Dividendo» y «Divisor» son los dos parámetros de esta función. Luego usamos «si» debajo y agregamos una condición «divisor! = 0». Si está satisfecho, devuelve la respuesta a la división porque le agregamos «retorno». De lo contrario, devuelve «nullopt», lo que significa que no hay ningún valor de tipo seguro. Ahora llamamos a main(). Para inferir «std::Optional» colocamos «divideFunc()» y le agregamos «27, 3» y asignamos el resultado a la variable «cociente».
Aquí utilizamos la palabra clave «auto» para que ajuste automáticamente su tipo de perfil. Después de eso, agregamos «if», que usa «tiene valor» para determinar si se recibe el valor del tipo. Luego, colocamos «cout», que representa el resultado almacenado en la variable «cociente», y la parte «else» contiene una declaración que representa la división por cero.
Código 2:
#incluir
Usar espacio de nombres estándar;
Electivoentero> función de división(entero dividendo, entero divisor) {
si (divisor != ) {
devolver dividendo/divisor;
}
devolver Selección invalida;
}
entero principal() {
auto negocio = función de división(27, 3);
si (negocio.valioso()) {
kut «Negocio es:» negocio.valor() endel;
} Otros {
kut «El divisor aquí es cero» endel;
}
devolver ;
}
Producción:
La salida presenta el resultado después de la división, lo que significa que el divisor no es cero. En este caso, «std::Optional» se utiliza para determinar si un valor es seguro para tipos.
Ejemplo 3:
Aquí, declaramos la variable «std::Optional», que es el «número» en main(). Luego, usando «if», colocamos la función has_value() con esta variable «número». Esto comprobará si hay un valor en la variable «número». Si la variable «número» contiene un valor, representará la declaración que agregamos después del «si». De lo contrario, generará la declaración que pusimos después de «else».
Ahora, inicializamos «número» con «92» y usamos «si» nuevamente debajo, donde la función has_value() agrega la variable «número» en «si como condición». Esto determina si la variable «número» tiene un valor. Si la variable «número» tiene un valor, se representará la oración que agregamos después de «si». De lo contrario, se representa la declaración que colocamos después de «else».
Código 3:
#incluir
entero principal() {
estándar::Electivoentero> dígito;
si (número.valioso()) {
estándar::kut «El número ya existe:» número.valor() estándar::endel;
} Otros {
estándar::kut «El número no existe.» estándar::endel;
}
dígito = 92;
si (número.valioso()) {
estándar::kut «El número ya existe:» número.valor() estándar::endel;
} Otros {
estándar::kut «El número no existe.» estándar::endel;
}
devolver ;
}
Producción:
Esto muestra primero la parte «else» porque no asignamos ningún valor a la variable «std::Optional». Luego asignamos un valor a la variable para mostrar ese valor en la siguiente línea.
Ejemplo 4:
Ahora, declaramos tres variables «std::Optional», a saber, «n1», «n2» y «n3». También asignamos valores a las variables «n2» y «n3», que son «29» y «45» respectivamente. La variable «n1» de la clase «std::Optional» está vacía aquí. Ahora, utilizamos «boolalpha», que ayuda a devolver el valor de retorno como «verdadero» o «falso» en lugar de «1» y «0».
Luego aprovechamos los operadores relacionales entre estas variables «std::Optional» y colocamos cada declaración dentro de «cout» para que también muestre los resultados de nuestra nueva comparación. Primero, marca «n3 > n2», luego marca «n3
Código 4:
#incluir
entero principal()
{
estándar::Electivoentero> n1;
estándar::Electivoentero> n2(29);
estándar::Electivoentero> n3(45);
estándar::kut estándar::alfa booleano;
estándar::kut «n3 > n2» (n3 > n2) estándar::endel;
estándar::kut «n3 (n3 n2) estándar::endel;
estándar::kut «n1 (n1 n2) estándar::endel;
estándar::kut «n1 == nulo» (n1 == estándar::Selección invalida) estándar::endel;
estándar::kut «n2==49» (n2 == 29) estándar::endel;
estándar::kut «n3==88» (n3 == 88) estándar::endel;
}
Producción:
El programa C++ que mencionamos anteriormente compara los valores de varias variables de tipo «std::Optional» e imprime los resultados en la salida.
Ejemplo 5:
Los archivos de encabezado incluidos en este código son «iostream», «fstream», «opcional» y «string». «fstream» contiene las definiciones de las dos funciones «ofstream» e «ifstream» que necesitamos en este código. Ahora, incluimos «namespace std» para no tenerlo separado de cada función. Luego aprovechamos «std: opcional» y declaramos una función llamada «ReadFileFunc» donde pasamos «const string& f_Name» como parámetro.
Luego tenemos «ifstream» para ayudar a leer el archivo cuyo nombre se agregará a la variable «f_name». Luego utilizamos el «if» que contiene una condición de que si el archivo no está abierto devolverá «nullopt» cuando lo agregamos debajo de la declaración «if». Luego, creamos otra función «fileContent» que ayuda a escribir contenido en el archivo cuando se abre. Aquí volvemos a poner «return fileContent» que también devuelve el contenido que agregamos al archivo después de abrirlo.
Ahora, aquí llamamos a «main()» e inicializamos la variable «f_Name» con el nombre del archivo «Sample.txt» que queremos abrir. Luego, aquí llamamos «ReadFileFunc()» y pasamos la variable «f_Name» en esta función, que intenta leer el archivo y almacenar su contenido en la variable «f_content». Debajo de esto, usamos las variables «has_value()» y «f_content» en «if». Si esta variable contiene un valor, también lo representará porque agregamos «cout» debajo de «if» donde también colocamos «f_content». De lo contrario, mostrará el error que agregamos después de «else».
Código 5:
#incluir
#incluir
#incluir
Usar espacio de nombres estándar;
ElectivoCadena> Función de lectura de archivos(constante Cadena& nombre) {
ifstream mi archivo(nombre);
si (!mi archivo.abrió()) {
devolver Selección invalida;
}
Contenido del archivo de cadena((istreambuf_iteratorpersonaje>(mi archivo)), istreambuf_iteratorpersonaje>());
devolver contenido del documento;
}
entero principal() {
constante Cadena f_Name = «muestra.txt»;
auto f_content = Función de lectura de archivos(nombre);
si (f_content.valioso()) {
kut «El contenido del documento es:\norte« f_content.valor() endel;
} Otros {
Chel «Error: el archivo no está abierto aquí» nombre endel;
}
devolver ;
}
Producción:
Aquí, muestra la declaración de error que agregamos en la sección «de lo contrario» como resultado del código proporcionado.
en conclusión
En este tutorial, exploramos la poderosa característica de C++ «std::Optional» y explicamos que proporciona una forma estandarizada de representar valores opcionales, eliminando el requisito de referencias nulas y mejorando la claridad y la seguridad del código de programación. Aprendimos que también mejora la capacidad de explicar problemas complejos y manejar errores con elegancia.
