c++ - soporta - solidity español

¿Cómo coloco algún código en múltiples espacios de nombres sin duplicar este código?

Question

Supongamos que tengo el método definido en los dos espacios de nombres diferentes:

namespace foo
{
    void print()
    {
        //do work...
    }
}

namespace bar
{
    void print()
    {
        //do work...
    }
}

Las funciones foo::print() y bar::print() son absolutamente iguales. Mi proyecto utiliza las numerosas llamadas de estas funciones.

¿Hay alguna forma de eliminar una de las definiciones de print() sin cambiar las llamadas de estas funciones ? Me refiero a algo como lo siguiente (por supuesto, el lenguaje C ++ no permite esta construcción, es solo un ejemplo ):

namespace foo, bar  //wrong code!
{
    void print()
    {
        //do work...
    }
}

Si no hay manera de refactorizar el código como deseo, dígame, ¿le gusta la siguiente decisión? ¿Estarás contento si tu proyecto contiene tal código? :)

namespace foo
{
    void print()
    {
        //do work...
    }
}

namespace bar
{
    void print()
    {
        foo::print();
    }
}

AÑADIR:

Gracias chicos, estoy completamente satisfecho con sus respuestas. Solo un momento quiero que aclares: ¿hay alguna diferencia entre using ::foo::print y using foo::print ?

Answer 1

¿Qué hay de using declaración:

namespace foo
{
    void print()
    {
        // do work ...
    }
}

namespace bar
{
    using ::foo::print;
}

Usar ::foo::print lugar de foo::print es un punto importante. Si tuvieras otro foo dentro de la bar :

namespace foo
{
    void print()
    {
        // 1 ...
    }
}

namespace bar
{
    namespace foo
    {
        void print()
        {
            // 2 ...
        }
    }

    using   foo::print; // refers to 2
    using ::foo::print; // refers to 1
}

entonces verías el mérito de usar :: . En resumen, prepending :: es una forma segura de garantizar que otro espacio de nombres anidado foo , que podría agregarse en el futuro, no le traiga sorpresas.

Answer 2

Con una declaración de using :

namespace bar
{
    using ::foo::print;
}

Answer 3

Probablemente la mejor solución es esta:

namespace foo
{
    void print()
    {
        //do work...
    }
}

namespace bar
{
    void print()
    {
        foo::print();
    }
}

Sin embargo puedes escribir:

namespace foo
{
    void print()
    {
        //do work...
    }
}

namespace bar
{
    void print()
    {
        //do work...
    }
}

Esto no se recomienda, pero no hay maldad. Los compiladores son lo suficientemente inteligentes como para entender que estas dos funciones son las mismas y se pueden usar el mismo código de ensamblaje.

Recuerde, la palabra clave del namespace es para los programadores, el compilador no se preocupa mucho por ellos, ya que los espacios de nombres del compilador son como prefijo para funciones / métodos / clases.

Answer 4

Puedes lograr esto con una declaración de using .

namespace foo
{
    void print()
    {
        //do work...
    }
}

namespace bar
{
    using foo::print;
}

EDITAR

Con respecto a la diferencia entre ::foo::print y foo::print : añadir un nombre calificado con :: significa que usted se refiere explícitamente al nombre en el espacio de nombres global. Esto se puede usar para seleccionar el global, incluso si hay otro elemento con el mismo nombre más cercano en su alcance.

Answer 5

Muestra

namespace Q {
    namespace V {
        void f(); // enclosing namespaces are the global namespace, Q, and Q::V
        class C { void m(); };
        }
        void V::f() { // enclosing namespaces are the global namespace, Q, and Q::V
        extern void h(); // ... so this declares Q::V::h
        }
        void V::C::m() { // enclosing namespaces are the global namespace, Q, and Q::V
    }
}