La plantilla std::is_nothrow_construtible de C++ STL está presente en el archivo de encabezado <type_traits> . La plantilla std::is_nothrow_construtible de C++ STL se usa para verificar si el tipo T dado es un tipo construible con el conjunto de argumentos o no y esto se sabe que no genera ninguna excepción. Devuelve el valor booleano verdadero si T es de tipo construible, de lo contrario devuelve falso.
Archivo de cabecera:
#include<type_traits>
Clase de plantilla:
template< class T, class... Args > struct is_nothrow_constructible;
Sintaxis:
std::is_nothrow_constructible<T, Args..>::value
Parámetro: La plantilla std::is_nothrow_construcible acepta los siguientes parámetros:
- T: Representa un tipo de dato.
- Args: Representa la lista de datos tipo T.
Valor devuelto: la plantilla std::is_nothrow_construcible devuelve una variable booleana como se muestra a continuación:
- Verdadero: si el tipo T es construible a partir de Args.
- Falso: si el tipo T no es construible a partir de Args.
A continuación se muestra el programa para demostrar std::is_nothrow_construcible en C++:
Programa 1:
// C++ program to illustrate
// std::is_nothrow_constructible
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
// Declare structures
struct X {
};
struct Y {
Y() {}
Y(X&)
noexcept {}
};
struct Z {
int n;
Z() = default;
};
// Driver Code
int main()
{
cout << boolalpha;
cout << "int is_nothrow_constructible? "
<< is_nothrow_constructible<int>::value
<< endl;
cout << "X() is is_nothrow_constructible? "
<< is_nothrow_constructible<X>::value
<< endl;
cout << "Y(X) is is_nothrow_constructible? "
<< is_nothrow_constructible<Y, X>::value
<< endl;
cout << "Z() is is_nothrow_constructible? "
<< is_nothrow_constructible<Z>::value
<< endl;
return 0;
}
int is_nothrow_constructible? true X() is is_nothrow_constructible? true Y(X) is is_nothrow_constructible? false Z() is is_nothrow_constructible? true
Programa 2:
// C++ program to illustrate
// std::is_nothrow_constructible
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
// Class GfG
class GfG {
int v1;
float v2;
public:
GfG(int n)
: v1(n), v2()
{
}
GfG(int n, double f) noexcept : v1(n), v2(f) {}
};
// Declare Structure
struct X {
int n;
X() = default;
};
// Driver Code
int main()
{
cout << boolalpha;
cout << "GfG is Nothrow-constructible from int? "
<< is_nothrow_constructible<GfG, int>::value
<< '\n';
cout << "GfG is Nothrow-constructible from int and float? "
<< is_nothrow_constructible<GfG, int, float>::value
<< '\n';
cout << "GfG is Nothrow-constructible from struct X? "
<< is_nothrow_constructible<GfG, X>::value
<< '\n';
}
GfG is Nothrow-constructible from int? false GfG is Nothrow-constructible from int and float? true GfG is Nothrow-constructible from struct X? false
Referencia: http://www.cplusplus.com/reference/type_traits/is_nothrow_construcible/
Publicación traducida automáticamente
Artículo escrito por bansal_rtk_ y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA