create - para que sirve el using namespace std en dev c++
Consejo de espacios de nombres C++ (9)
A veces declaro espacios de nombres profundos como un par de macros en un encabezado separado
namespace.h
#define NAMESPACE_TIER1_TIER2_TIER3 /
namespace tier1 { /
namespace tier2 { /
namespace tier3 {
#define END_NAMESPACE_TIER1_TIER2_TIER3 }}}
Para usarlo en otro lugar:
anotherfile.h
#include "./namespace.h"
NAMESPACE_TIER1_TIER2_TIER3;
/* Code here */
END_NAMESPACE_TIER1_TIER2_TIER3;
Los puntos y comas redundantes después de la macro deben evitar sangría adicional.
Solo me estoy enseñando espacios de nombres C ++ (viniendo de un fondo de C #) y realmente estoy empezando a pensar que incluso con todas las cosas que C ++ hace mejor que la mayoría de los otros lenguajes, ¡los espacios de nombres anidados no son uno de ellos!
Estoy en lo cierto al pensar que para declarar algunos espacios de nombres anidados tengo que hacer lo siguiente:
namespace tier1
{
namespace tier2
{
namespace tier3
{
/* then start your normal code nesting */
}
}
}
Opuesto a:
namespace tier1::tier2::tier3
{
}
à la C #?
Esto se vuelve aún más demente cuando necesito reenviar declarar:
namespace tier1
{
namespace tier2
{
namespace forward_declared_namespace
{
myType myVar; // forward declare
}
namespace tier3
{
/* then start your normal code nesting */
class myClass
{
forward_declared_namespace::myType myMember;
}
}
}
}
Teniendo en cuenta que un sistema típico que desarrollo consiste en:
MyCompany::MySolution::MyProject::System::[PossibleSections]::Type
¿Es por eso que no se tiende a ver mucho uso de espacios de nombres en ejemplos de C ++? ¿O generalmente solo espacios de nombres individuales (no anidados)?
ACTUALIZAR
Para cualquier persona interesada, así es como terminé abordando este tema.
Al menos como una pequeña ayuda, en algunos casos puede hacer esto:
namespace foo = A::B::C::D;
Y luego referencia A :: B :: C :: D como foo. Pero solo en algunos casos
Descubrí que puedes hacer una especie de mímica del espacio de nombres c # como este;
namespace ABC_Maths{
class POINT2{};
class Complex{};
}
namespace ABC_Maths_Conversion{
ABC_MATHS::Complex ComplexFromPOINT2(ABC_MATHS::POINT2)
{return new ABC_MATHS::Complex();}
ABC_MATHS::POINT4 POINT2FromComplex(ABC_MATHS::COMPLEX)
{return new ABC_MATHS::POINT2();}
}
namespace ABC
{
}
Pero el código no parece ser muy ordenado. y yo esperaría tener un uso prolongado
Es mejor anidar tanta funcionalidad en clases algo así como
namespace ABC{
class Maths{
public:
class POINT2{};
class Complex:POINT2{};
class Conversion{
public:
static Maths.Complex ComplexFromPOINT2(MATHS.POINT2 p)
{return new MATHS.Complex();}
static MATHS.POINT2 POINT2FromComplex(MATHS.COMPLEX p)
{return new ABC::MATHS.POINT2();}// Can reference via the namespace if needed
} /*end ABC namespace*/
Y eso todavía es un poco largo. pero se siente un poco OO.
Y oye cómo parece estar mejor hecho
namespace ABC
{
class POINT2{};
class Complex:POINT2{};
Complex ComplexFromPOINT2(POINT2 p){return new Complex();}
POINT2 POINT2FromComplex(Complex){return new POINT2();}
}
escucha cómo se verían los usos
int main()
{
ABC_Maths::Complex p = ABC_Maths_Conversion::ComplexFromPOINT2(new ABC_MATHS::POINT2());
// or THE CLASS WAY
ABC.Maths.Complex p = ABC.Maths.Conversion.ComplexFromPOINT2(new ABC.Maths.POINT2());
// or if in/using the ABC namespace
Maths.Complex p = Maths.Conversion.ComplexFromPOINT2(new Maths.POINT2());
// and in the final case
ABC::Complex p = ABC::ComplexFromPOINT2(new ABC::POINT2());
}
ha sido interesante descubrir por qué nunca usé espacios de nombres c ++ como lo haría con c #. Sería demasiado largo, y nunca funcionaría de la misma manera que los espacios de nombres c #.
el mejor uso para los espacios de nombres en c ++ es dejar de decir que mi función super cout (que suena cada vez que se la llama) se mezcle con la función std :: cout (que es mucho menos impresionante).
El hecho de que c # y c ++ tengan espacios de nombres, no significa que el espacio de nombres signifique lo mismo. son diferentes pero similares. La idea de espacios de nombres c # debe provenir de espacios de nombres c ++. alguien debe haber visto qué cosa similar pero diferente podría hacer, y no tenía suficiente poder de imaginación para darle su nombre original como "ClassPath", que tendría más sentido ya que es un camino hacia las clases en lugar de proporcionar nombrando espacios donde cada espacio puede tener los mismos nombres
Espero que esto ayude a alguien
Olvidé decir que todas estas formas son válidas, y el uso moderado de las dos primeras se puede incorporar al tercero para crear una biblioteca que tenga sentido, es decir (no es un gran ejemplo)
_INT::POINT2{}
y
_DOUBLE::POINT2{}
para que pueda cambiar el nivel de precisión mediante el uso
#define PREC _DOUBLE
// or #define PREC _INT
y luego creando una instancia de PREC :: POINT2 para doble precisión POINT2
Eso no es algo fácil de hacer con espacios de nombres de c # o java
obviamente ese es solo un ejemplo. Piense en cómo se lee el uso.
En primer lugar, puede evitar la sangría del espacio de nombres, porque no hay ninguna razón para eso.
El uso de espacios de nombres en los ejemplos no mostrará la energía de los espacios de nombres. Y su poder como para mí está dividiendo las áreas de dominio una de otra. Divida las clases de utilidad de las comerciales.
Simplemente no mezcle diferentes jerarquías de espacio de nombres en el archivo .h. Los espacios de nombres son un tipo de comentario adicional para su interfaz de declaración de funciones. Buscar en los espacios de nombres y los nombres de las clases debería explicar muchas cosas.
namespace product
{
namespace DAO
{
class Entity
{
};
Estás sobreutilizándolos (y no obtendrás nada a cambio).
Los espacios de nombres C ++ no pretendían ser un mecanismo de diseño: están ahí simplemente para evitar conflictos de nombres. Realmente no desea o necesita utilizar espacios de nombres anidados en el 99.99% de las situaciones.
Un buen ejemplo del uso correcto de los espacios de nombres en C ++ es la Biblioteca estándar de C ++. Todo en esta biblioteca bastante grande se coloca en un solo espacio de nombres llamado std : no hay ningún intento o necesidad de dividir la biblioteca en (por ejemplo) un espacio de nombres secundario de E / S, un espacio de nombres matemático secundario, un espacio de nombres de contenedor etc.
La herramienta básica para modelar en C ++ es la clase (y en cierta medida la plantilla), no el espacio de nombres. Si siente la necesidad de anidar, debe considerar el uso de clases anidadas, que tienen las siguientes ventajas sobre los espacios de nombres:
- ellos tienen metodos
- ellos pueden controlar el acceso
- no pueden ser reabiertos
Habiendo considerado esto, si todavía desea utilizar espacios de nombres anidados, hágalo de todas formas; no hay nada técnicamente incorrecto al usarlos de esta manera.
Los espacios de nombres de C ++ fueron una gran mejora con respecto a la oferta anterior (es decir, sin espacios de nombres). Los espacios de nombres de C # han extendido el concepto y han corrido con él. Te aconsejo que mantengas tus espacios de nombres en una estructura simple y plana.
EDITAR ¿Aconsejas eso debido a las deficiencias que he descrito aquí?
Simplemente "Sí". Los espacios de nombres de C ++ no fueron diseñados para ayudarlo a particionar su lógica y bibliotecas de la manera en que lo hacen en C #.
El objetivo de los espacios de nombres C ++ es detener el problema del mundo real que enfrentan los desarrolladores de C, donde experimentan colisiones de nombres cuando utilizan dos bibliotecas de terceros que exportan los mismos nombres de funciones. Los desarrolladores de C tenían varias soluciones para ello, pero podría ser un dolor serio.
La idea era que STL, etc. tenía el std:: nombres std:: , las bibliotecas proporcionadas por "XYZ Corp" tendrían un espacio de nombres xyz:: , el que trabajas para "ABC corp" pondría todas tus cosas en un solo abc:: namespace.
Puede saltarse la sangría. A menudo escribo
namespace myLib { namespace details {
/* source code */
}; }; /* myLib::details */
El código fuente de C ++ finalmente se compila en binario, a diferencia de C # / Java que permanece en el binario. Por lo tanto, el espacio de nombres solo proporciona una solución fina para el conflicto de nomenclatura variable. No está destinado a la jerarquía de clases.
A menudo mantengo uno o dos niveles de espacio de nombres en el código.
lo que hago cuando declarar hacia adelante se ve así:
namespace abc { namespace sub { namespace subsub { class MyClass; }}}
Mis declaraciones hacia adelante están contraídas en una sola línea. La legibilidad de la declaración directa se sacrifica a cambio de la legibilidad del resto del código. Y para las definiciones, tampoco uso indentaciones:
namespace abc {
namespace sub {
namespace subsub {
class MyClass
{
public:
MyClass();
void normalIntendationsHere() const;
};
}
}
}
Usar este estilo requiere un poco de disciplina al principio, pero es el mejor compromiso para mí.