La declaración usando el espacio de nombres estándar generalmente se considera una mala práctica. La alternativa a esta declaración es especificar el espacio de nombres al que pertenece el identificador utilizando el operador de alcance (::) cada vez que declaramos un tipo.
Aunque el enunciado nos ahorra tener que teclear estándar:: Siempre que deseamos acceder a una clase o tipo definido en el espacio de nombres estándar, importa la totalidad del enfermedad de transmisión sexual espacio de nombres en el espacio de nombres actual del programa. Tomemos algunos ejemplos para entender por qué esto podría no ser algo tan bueno.
Digamos que deseamos utilizar cout del espacio de nombres estándar. entonces escribimos
Ejemplo 1:
CPP
#include> using> namespace> std;> > cout <<>' Something to Display'>;> |
>
>
Ahora, en una etapa posterior de desarrollo, deseamos utilizar otra versión de cout que esté implementada de forma personalizada en alguna biblioteca llamada foo (por ejemplo).
CPP
#include> #include> using> namespace> std;> > cout <<>' Something to display'>;> |
>
>
Observe que ahora hay una ambigüedad: ¿a qué biblioteca apunta cout? El compilador puede detectar esto y no compilar el programa. En el peor de los casos, es posible que el programa aún se compile pero llame a la función incorrecta, ya que nunca especificamos a qué espacio de nombres pertenecía el identificador.
Los espacios de nombres se introdujeron en C++ para resolver conflictos de nombres de identificadores. Esto aseguró que dos objetos pudieran tener el mismo nombre y aún así ser tratados de manera diferente si pertenecían a espacios de nombres diferentes. Observe cómo ha ocurrido exactamente lo contrario en este ejemplo. En lugar de resolver un conflicto de nombres, en realidad creamos un conflicto de nombres.
Cuando importamos un espacio de nombres, básicamente estamos incorporando todas las definiciones de tipos al ámbito actual. El espacio de nombres estándar es enorme. Tiene cientos de identificadores predefinidos, por lo que es posible que un desarrollador pase por alto el hecho de que hay otra definición de su objeto previsto en la biblioteca estándar. Sin ser conscientes de esto, pueden proceder a especificar su propia implementación y esperar que se utilice en partes posteriores del programa. Por tanto, existirían dos definiciones para el mismo tipo en el espacio de nombres actual. Esto no está permitido en C++, e incluso si el programa se compila no hay forma de saber qué definición se está utilizando y en qué lugar.
La solución al problema es especificar explícitamente a qué espacio de nombres pertenece nuestro identificador utilizando el operador de alcance (::). Por lo tanto, una posible solución al ejemplo anterior puede ser
CPP
#include> #include> > // Use cout of std library> std::cout <<>'Something to display'>;> > // Use cout of foo library> foo::cout <>'Something to display'>;> |
>
cuantos mb hay en un gb
>
Pero tener que escribir estándar:: cada vez que definimos un tipo es tedioso. También hace que nuestro código parezca más complicado con muchas definiciones de tipos y dificulta la lectura del código. Considere, por ejemplo, el código para obtener la hora actual en el programa.
Ejemplo 2:
CPP
#include> #include> > auto> start = std::chrono::high_performance_clock::now()> > // Do Something> > auto> stop> >= std::chrono::high_peformance_clock::now();> auto> duration> >= std::duration_cast(stop - start);> |
>
>
El código fuente, que está plagado de definiciones de tipos largas y complicadas, no es muy fácil de leer. Esto es algo que los desarrolladores intentan evitar, ya que para ellos la mantenibilidad del código es lo más importante.
Hay algunas formas de resolver este dilema, es decir, especificar el espacio de nombres exacto sin ensuciar el código con palabras clave estándar.
Considere usar typedefs
typedefs nos evita escribir definiciones de tipos largas. En nuestro ejemplo 1, podríamos resolver el problema usando dos typedefs, uno para la biblioteca estándar y otro para foo.
CPP
ordenar una lista de matrices en java
#include> #include> > typedef> std::cout cout_std;> typedef> foo::cout cout_foo;> > cout_std <<>'Something to write'>;> cout_foo <<>'Something to write'>;> |
>
>
En lugar de importar espacios de nombres completos, importe un espacio de nombres truncado
En el ejemplo 2, podríamos haber importado solo el espacio de nombres crono en std.
CPP
#include> #include> > // Import only the chrono namespace under std> using> std::chrono;> > auto> start = high_performance_clock::now();> > // Do Something> auto> stop = high_performance_clock::now();> auto> duration duration_cast(stop - start);> |
>
>
También podemos usar la declaración para importar un único identificador. Para importar sólo std::cout podríamos usar
using std::cout;>
Si aún importa espacios de nombres completos, intente hacerlo dentro de funciones o de alcance limitado y no en el alcance global.
Utilice la declaración std del espacio de nombres dentro de las definiciones de funciones o clases, definiciones de estructuras. Al hacerlo, las definiciones del espacio de nombres se importan a un ámbito local y al menos sabemos dónde se pueden originar los posibles errores si surgen.
CPP
#include> > // Avoid this> using> namespace> std;> > void> foo()> {> >// Inside function> >// Use the import statement inside limited scope> >using> namespace> std;> > >// Proceed with function> }> |
>
>
Conclusión.
Hemos discutido métodos alternativos para acceder a un identificador desde un espacio de nombres. En todos los casos, evite importar espacios de nombres completos al código fuente.
Si bien puede llevar algún tiempo aprender y desarrollar buenas prácticas de codificación, generalmente dan resultados a largo plazo. Escribir código limpio, inequívoco y robusto sin errores debería ser la intención de cualquier desarrollador de programación.