¿Qué significa #include"std_lib_facilities.h en C++? Lo vi en el nuevo libro del padre de C++, ¿por qué no se puede compilar?
El código es el siguiente:
//Nombre el archivo: std_lib_facilities.h y luego agréguelo a su proyecto.
/*
Título del curso simple "Programación: principios y práctica usando C++"
Úselo durante las primeras semanas.
Proporciona los encabezados estándar más comunes (en el espacio de nombres global)
y soporte mínimo para excepciones/errores.
Estudiantes: Por favor, no intenten comprender los detalles del título.
Todo estará explicado. Este encabezado se utiliza principalmente para que no entiendas todos los conceptos a la vez.
Fecha de revisión 2010: simple_error() añadido
*/
#ifndef H112
#Definición H112 201004L
# include & ltiostream & gt
# include & ltfstream & gt
# include & ltsstream & gt
# include & ltcmath & gt
# incluir & ltcstdlib & gt
# incluir & ltstring& gt
# incluir & ltlist& gt
# incluir & ltvector & gt
# include & ltalgorithm& gt
# include & ltstdexcept & gt
// -
# VER Centro de Logística Internacional
# include & lthash _ map & gt
Usar stdext::hash _ map;
# De lo contrario
# include & ltext/hash_map>
Usar__GNU_cxx::hash_map;
Espacio de nombres __gnu_cxx {
Plantilla<& gt struct hash & ltSTD::string & gt;
{
size_t operator()(const STD::string & s) constante
{
Devuelve valor hash& ltchar * & gt(( s . c _ str());
}
};
} //Espacio de nombres __gnu_cxx
#endif
// -
#Definir mapa hash de mapa desordenado
// -
typedef long Unicode
// -
usar espacio de nombres std
plantilla y clase ltT y caracteres gt Cadena a cadena (const T & ampt)
{
ostringstream os
os & lt& ltt;
return OS .str ();
}
struct Range _ error:out _ of _ Range {//Informe de errores de rango vectorial mejorado
int index;
Rango _ error(int I):fuera _ de _ Rango(" Error de rango:"+a _ cadena(I)), índice(i) { }
};
//Vector de verificación de rango normal (sin verificación de iterador):
Plantilla y clase ltT y vector de estructura gt: public STD::Vector & lt;T & gt{
typedef typename std::vector<T & gt* tamaño tipo tamaño tipo;
Vector() { }
Vector explícito( tamaño _ tipo n):STD::Vector & lt ;T & gt(n) {}
Vector (tamaño_tipo n, const T & ampv):STD::vector & lt; n, v) {}
Plantilla& ltNivel 1& gt
Vector(yo primero, yo último)
:STD::vector & lt;T & gt(nombre, apellido){}
T & ampoperator[](unsigned int i) //En lugar de regresar en (I);
{
if(i<0||this->size()<=I)throw Range_error(I);
return std:: vector <T> *operador[](uno);
}
const T & operador[](entero sin signo I)const
{
if(i<0||this->size()<=I)throw Range_error(I);
return std: :vector <T>*operator[](1);
}
};
//Asqueroso truco de macro para obtener un rango Verificar vector:
#Definir vector vector
//Cadena de verificación de rango normal (sin verificación de iterador):
Cadena de estructura: std::string {
String() { }
string(const char * p):STD::string(p){ }
Cadena (cadena constante y amperios):STD::string { }
Plantilla y ltCategoría S y gtString:STD: :string { }
String(int sz, char val) :std ::string(sz, val) {}
Plantilla y clase ltIter y gtString(Iter p1, Iter p2 ) : std::string(p1, p2) { }
char &erator[](unsigned int i) // en lugar de regresar en (i);
{
if (i<0 | | tamaño()<= I) throw Rango _ error(I);
return STD::string::operator[](I);
}
Suma de caracteres constante.
operador[](entero sin signo I) const
{
if(i<0 | | size()<= I)throw Range_error(I); return STD::string::operator[](I);
}
};
#ifndef _MSC_VER
namespace__gnu_cxx {
plantilla & lt& gt struct hash & lt string & gt
{
operador size_t() (cadena constante &s)constante
{
Devuelve el valor hash<STD::string>()(s);
}
};
} //Espacio de nombres __gnu_cxx
#endif
Salida de estructura: runtime_error {
Salir(): runtime_error("Salir") {}
};
// error() simplemente pretende arrojar:
Error de anulación en línea (cadena constante y amperios)
{
Error de tiempo de ejecución ;
}
Error de anulación en línea (const char string&s,const string&s2)
{
error(s+S2);
}
error de anulación en línea (cadena constante y amperios, int i)
{
sistema operativo ostringstream
os & lt& lts & lt& lt":" & lt& lti;
error(OS . str());
}
# if _ MSC _ VER & lt; 1500
// Hack de macros desagradable para obtener cadenas de rango verificado:
#define string string
// MS C++ 9.0 tiene una versión integrada -in aserción para verificaciones de rango de cadenas
//Y usa "std::string" en varios lugares, por lo que el reemplazo de macros falla
#endif
Plantilla & ltT class & gtchar * as _ bytes(T &i) //Requerido para E/S binarias
{
Dirección = &i) //Obtener la dirección del primer byte
//Memoria utilizada para almacenar objetos
Devuelve static _ cast & ltchar * & gt(addr); //Trata la memoria como bytes
}
inline void keep_window_open()
{
CIN clear();
cout & lt& lt"Ingrese un carácter para salir\n";
char ch
CIN>& gtch;
return;
}
vacío en línea keep_window_open(string s)
{
if (s== " ") devuelve
clear(); p >cin.ignore(120, '\n');
for(;;) {
cout & lt& lt"Ingrese "& lt& lts & lt& lt" para exit\ n";
Cadena ss;
Y (CIN>>ss&&ss! =s)
cout & lt& lt"Por favor ingrese"& l
t& lts & lt& lt"Salir\n";
Regresar;
}
}
//Introducido en el Capítulo 5 función de error utilizada (solo) antes de error():
inline void simple _ error(string s)//Escribe ` ` error: s y sal del programa
{
cerr & lt& ltError: "& lt& lts & lt& lt\ n ';
keep_window_open(). //Para algunos entornos Windows
Salir(1) ;
}
//Hacer que std::min() y std::max() sean accesibles:
#Minimum
#Maximum value
# include & ltiomanip & gt
IOS _ base & amp regular integrados (ios _ base & ampb) //Mejora la fijeza y la cientificidad
{
b.setf(ios_base::fmtflags(0), IOs_base::float field);
Devolver b;
}
//Verifique la conversión de reducción (conversión de tipo) en tiempo de ejecución:
Plantilla y nivel ltR, nivel A y difusión estrecha gt (respuesta constante A y amp
{
R R = R(a);
if (A(r)!=a)error(string(" pérdida de información "));
return r;
}
en línea int randint(int max){ return rand()% max;}
en línea int randint(int min, int max){ return randint(max-min )+min;}
inline double sqrt(int x){ return sqrt(double(x));} //Hacer coincidir C++0x
#endif