Espacios con Nombre (Namespaces)¶

Introducción¶

Un espacio con nombre (namespace) es una zona separada donde se pueden declarar y definir: - Variables - Funciones - Clases - Estructuras - Cualquier identificador de tipo

Propósito principal: Evitar conflictos de nombres entre diferentes bibliotecas o partes de un programa.

Problema sin Namespaces¶

// biblioteca1.h
class Conjunto { /* ... */ };

// biblioteca2.h
class Conjunto { /* ... */ };  // ❌ ERROR: redefinición

// main.cpp
#include "biblioteca1.h"
#include "biblioteca2.h"  // Conflicto de nombres

Solución con Namespaces¶

// biblioteca1.h
namespace matematicas {
    class Conjunto { /* ... */ };
}

// biblioteca2.h
namespace graficos {
    class Conjunto { /* ... */ };
}

// main.cpp
matematicas::Conjunto c1;  // ✅ OK
graficos::Conjunto c2;     // ✅ OK

Espacio Global¶

Antes de usar namespaces, todas las declaraciones estaban en el espacio global:

int x;              // Variable global
void funcion();     // Función global
struct Punto {};    // Estructura global

Con namespaces, podemos organizar el código:

namespace proyecto {
    int x;
    void funcion();
    struct Punto {};
}

Declaración y Definición¶

Sintaxis Básica¶

namespace <identificador> {
    // Declaraciones y definiciones
}

Ejemplo: Puntos 2D vs 3D¶

// Fichero: puntos.h

namespace espacio_2D {
    struct Punto {
        int x;
        int y;
    };
}

namespace espacio_3D {
    struct Punto {
        int x;
        int y;
        int z;
    };
}

Dos estructuras con el mismo nombre (Punto), pero en espacios diferentes.

Formas de Uso¶

1. Acceso Completo (Sin Activar)¶

#include "puntos.h"

int main() {
    espacio_2D::Punto p1;  // Acceso completo con ::
    espacio_3D::Punto p2;

    p1.x = 10;
    p2.x = 20;
}

Operador ::: Especificador de ámbito (scope resolution operator)

2. Forma Directiva: `using namespace`¶

using namespace <identificador>;

Activa todo el espacio para uso por defecto:

#include "puntos.h"

using namespace espacio_2D;  // Activar espacio completo

int main() {
    Punto p1;              // ✅ espacio_2D::Punto (activo)
    espacio_3D::Punto p2;  // Necesita especificar (no activo)
}

Ejemplo con std:

#include <iostream>

using namespace std;  // Activar espacio std

int main() {
    cout << "Hola" << endl;  // ✅ Sin std:: adelante
    cin.get();
}

Sin using namespace std:

#include <iostream>

int main() {
    std::cout << "Hola" << std::endl;  // Necesita std::
    std::cin.get();
}

3. Forma Declarativa: `using` Individual¶

using <nombre_espacio>::<identificador>;

Activa solo un identificador específico:

#include "puntos.h"

using espacio_3D::Punto;  // Solo activa Punto de espacio_3D

int main() {
    Punto p2;              // ✅ espacio_3D::Punto (activo)
    espacio_2D::Punto p1;  // Necesita especificar
}

Ejemplo con std:

#include <iostream>

using std::cout;  // Solo activar cout
using std::endl;

int main() {
    cout << "Hola" << endl;  // ✅ Estos están activos
    std::cin.get();          // ❌ cin necesita std::
}

Comparación de Formas¶

Forma	Sintaxis	Activa	Ejemplo
Completa	`espacio::item`	Nada	`std::cout << "Hi"`
Directiva	`using namespace espacio;`	Todo el espacio	`cout << "Hi"`
Declarativa	`using espacio::item;`	Solo ese item	`cout << "Hi"` pero `std::cin.get()`

Ejemplo Completo 1: Dos Namespaces¶

Código Fuente¶

#include <iostream>

namespace uno {
    int x;
}

namespace dos {
    int x;
}

using namespace uno;  // Activar espacio "uno"

int main() {
    x = 10;         // uno::x (activo)
    dos::x = 30;    // dos::x (necesita especificar)

    std::cout << x << ", " << dos::x << std::endl;
    std::cin.get();
    return 0;
}

Output:

10, 30

Análisis a Bajo Nivel¶

Ensamblador¶

_DATA SEGMENT
int uno::x DD 00H        ; Variable del namespace "uno"
int dos::x DD 00H        ; Variable del namespace "dos"
_DATA ENDS

main:
    ; x = 10;  (uno::x)
    mov     DWORD PTR uno::x, 10

    ; dos::x = 30;
    mov     DWORD PTR dos::x, 30

    ; Imprimir valores
    mov     edx, DWORD PTR uno::x
    mov     rcx, QWORD PTR std::cout
    call    std::basic_ostream::operator<<

    mov     edx, DWORD PTR dos::x
    mov     rcx, rax
    call    std::basic_ostream::operator<<

Observaciones Clave¶

A bajo nivel: 1. No existe "activado" vs "no activado" 2. Todas las variables llevan el namespace como prefijo: uno::x, dos::x 3. El compilador traduce todo a nombres completos 4. IDA muestra los nombres con el namespace incluido

Conclusión: using namespace es solo sintaxis para el programador. El compilador siempre usa nombres completos internamente.

Espacios Anidados¶

Concepto¶

Los namespaces pueden contener otros namespaces:

namespace nivel1 {
    int x;

    namespace nivel2 {
        int x;

        namespace nivel3 {
            int x;
        }
    }
}

Ejemplo Completo¶

#include <iostream>

namespace uno {
    int x;

    namespace dos {
        int x;

        namespace tres {
            int x;
        }
    }
}

using std::cout;
using std::endl;
using uno::x;  // Solo activar uno::x

int main() {
    x = 10;                  // uno::x (activo)
    uno::dos::x = 30;        // Necesita ruta completa
    uno::dos::tres::x = 50;  // Necesita ruta completa

    cout << x << ", " 
         << uno::dos::x << ", " 
         << uno::dos::tres::x << endl;

    std::cin.get();
    return 0;
}

Output:

10, 30, 50

Análisis a Bajo Nivel¶

_DATA SEGMENT
int uno::x DD 00H              ; Primer nivel
int uno::dos::x DD 00H         ; Segundo nivel
int uno::dos::tres::x DD 00H   ; Tercer nivel
_DATA ENDS

main:
    ; x = 10;
    mov     DWORD PTR uno::x, 10

    ; uno::dos::x = 30;
    mov     DWORD PTR uno::dos::x, 30

    ; uno::dos::tres::x = 50;
    mov     DWORD PTR uno::dos::tres::x, 50

Observación: Todos los niveles se aplanan a nombres únicos con :: como separador.

Espacios Anónimos¶

Concepto¶

Namespaces sin nombre:

namespace {
    int x = 10;  // Variable interna al archivo
}

Propósito: Crear identificadores accesibles solo en el archivo actual.

Ejemplo¶

namespace Nombre {
    int f();
    char s;
    void g(int);
}

namespace {
    int x = 10;  // Solo accesible desde aquí hasta el fin del archivo
}

namespace Nombre {
    int f() {
        return x;  // ✅ Puede acceder a x
    }
}

Características: - No necesita especificar nombre para acceder - Variables/funciones son internas al archivo - Alternativa moderna a static global

Equivalencia con `static`¶

Forma antigua:

static int x = 10;  // Variable interna al archivo

Forma moderna (C++):

namespace {
    int x = 10;  // Preferido en C++ moderno
}

Nota: La especificación de C++ recomienda usar namespaces anónimos en lugar de static para evitar confusión con otros usos de static.

Namespace Inline¶

Concepto¶

namespace uno {
    int x;

    inline namespace dos {
        int i;  // Embebido en "uno"
    }
}

Efecto: El contenido del namespace inline se "aplana" dentro del namespace padre.

Ejemplo¶

#include <iostream>

namespace uno {
    int x;

    inline namespace dos {  // inline: contenido embebido en "uno"
        int i;
    }
}

using namespace uno;

int main() {
    x = 10;   // uno::x
    i = 30;   // uno::i (no necesita uno::dos::i)

    std::cout << x << ", " << i << std::endl;
    return 0;
}

Sin inline:

uno::dos::i = 30;  // Necesitaría ruta completa

Con inline:

uno::i = 30;  // Acceso directo como si estuviera en "uno"

Namespace Inline Anónimo¶

namespace uno {
    int x;

    inline namespace {  // Sin nombre
        int i;
    }
}

int main() {
    uno::x = 10;
    uno::i = 30;  // ✅ Accesible directamente desde "uno"
}

No es necesario darle nombre porque está embebido en el padre.

A Bajo Nivel¶

_DATA SEGMENT
int uno::x DD 00H
int uno::i DD 00H    ; "dos" desaparece, i está directamente en "uno"
_DATA ENDS

El namespace inline desaparece en el código compilado.

Alias de Namespaces¶

Sintaxis¶

namespace <alias> = <nombre_espacio>;

Ejemplo¶

namespace nombredemasiadolargoycomplicado {
    int x;
    void funcion();
}

namespace ndlyc = nombredemasiadolargoycomplicado;  // Alias

int main() {
    ndlyc::x = 10;          // ✅ Más corto
    ndlyc::funcion();
}

Uso común: Simplificar nombres largos o crear shortcuts.

Namespaces en Múltiples Archivos¶

Concepto¶

Un namespace puede extenderse a través de múltiples archivos:

archivo1.cpp:

namespace proyecto {
    int x = 10;
    void funcion1() { /* ... */ }
}

archivo2.cpp:

namespace proyecto {  // Mismo namespace
    void funcion2() { /* ... */ }
}

main.cpp:

namespace proyecto {  // Se extiende más
    void funcion3() { /* ... */ }
}

int main() {
    proyecto::x = 5;       // De archivo1.cpp
    proyecto::funcion1();  // De archivo1.cpp
    proyecto::funcion2();  // De archivo2.cpp
    proyecto::funcion3();  // De este archivo
}

El namespace std funciona así: se define en todos los headers estándar.

Análisis para Reversing¶

Reglas Generales¶

using namespace no existe a bajo nivel
Todo se convierte a nombres completos

El namespace aparece como prefijo

namespace espacio { int x; }

int espacio::x DD 00H

No hay diferencia entre "activo" e "inactivo"
IDA muestra siempre el nombre completo

Funciones también llevan el namespace

namespace math { void calc(); }

call math::calc

Patrón de Reconocimiento¶

En IDA/Ghidra:

std::cout
std::operator<<
proyecto::variable
math::funcion

Indica: - std → Biblioteca estándar - proyecto → Namespace personalizado - math → Posible biblioteca matemática

Ejemplo de Análisis¶

Código:

namespace game {
    class Player {
        int health;
    public:
        void damage(int amount);
    };
}

void game::Player::damage(int amount) {
    health -= amount;
}

int main() {
    game::Player p;
    p.damage(10);
}

Ensamblador:

; Función con namespace completo en el nombre
game::Player::damage:
    mov     rax, QWORD PTR [rcx]    ; this->health
    sub     eax, edx                 ; health -= amount
    mov     DWORD PTR [rcx], eax
    ret

main:
    lea     rcx, QWORD PTR p$[rsp]
    mov     edx, 10
    call    game::Player::damage    ; Nombre completo visible

Diferencias con/sin `using namespace`¶

Con `using namespace`¶

Código:

#include <iostream>
using namespace std;

int main() {
    cout << "Hi" << endl;
}

Ensamblador:

main:
    lea     rdx, OFFSET FLAT:$SG001
    mov     rcx, QWORD PTR std::cout
    call    std::operator<<          ; ← Siempre std:: en ASM

    lea     rdx, OFFSET FLAT:std::endl
    mov     rcx, rax
    call    std::operator<<

Sin `using namespace`¶

Código:

#include <iostream>

int main() {
    std::cout << "Hi" << std::endl;
}

Ensamblador:

main:
    lea     rdx, OFFSET FLAT:$SG001
    mov     rcx, QWORD PTR std::cout
    call    std::operator<<          ; ← Idéntico al anterior

    lea     rdx, OFFSET FLAT:std::endl
    mov     rcx, rax
    call    std::operator<<

Conclusión: El ensamblador es idéntico. La diferencia solo existe en el código fuente.

Buenas Prácticas¶

✅ Recomendado¶

// En archivos .cpp
using namespace std;  // OK en implementación

// Uso selectivo
using std::cout;
using std::endl;

// Namespaces para organizar código
namespace mi_proyecto {
    // Todo tu código
}

❌ No Recomendado¶

// En archivos .h (headers)
using namespace std;  // ❌ Contamina a todos los que incluyan

// Namespace sin propósito
namespace n { int x; }  // ❌ Nombre poco descriptivo

🔍 En Headers¶

Preferir forma completa:

// archivo.h
#include <iostream>

void imprimir() {
    std::cout << "Mensaje" << std::endl;  // ✅ Forma completa
}

Evitar using en headers:

// archivo.h
using namespace std;  // ❌ Forzará a todos los que incluyan a usar "std"

Resolución de Conflictos¶

Problema¶

namespace lib1 { void funcion(); }
namespace lib2 { void funcion(); }

using namespace lib1;
using namespace lib2;

int main() {
    funcion();  // ❌ ERROR: ambiguo
}

Error:

error: call to 'funcion' is ambiguous

Solución 1: Especificar Namespace¶

int main() {
    lib1::funcion();  // ✅ Explícito
    lib2::funcion();
}

Solución 2: Alias¶

namespace l1 = lib1;
namespace l2 = lib2;

int main() {
    l1::funcion();
    l2::funcion();
}

Solución 3: `using` Selectivo¶

using lib1::funcion;  // Solo activar esta

int main() {
    funcion();         // lib1::funcion
    lib2::funcion();   // Especificar la otra
}

Namespaces y Clases¶

Clase dentro de Namespace¶

namespace matematicas {
    class Vector {
        double x, y;
    public:
        Vector(double x, double y);
        double modulo();
    };
}

// Definición fuera
matematicas::Vector::Vector(double x, double y) 
    : x(x), y(y) {}

double matematicas::Vector::modulo() {
    return sqrt(x*x + y*y);
}

Uso¶

int main() {
    matematicas::Vector v(3, 4);
    cout << v.modulo() << endl;  // Output: 5
}

A Bajo Nivel¶

; Constructor
matematicas::Vector::Vector:
    mov     QWORD PTR [rcx], rdx    ; this->x = x
    mov     QWORD PTR [rcx+8], r8   ; this->y = y
    ret

; Método
matematicas::Vector::modulo:
    movsd   xmm0, QWORD PTR [rcx]      ; x
    mulsd   xmm0, xmm0                  ; x*x
    movsd   xmm1, QWORD PTR [rcx+8]    ; y
    mulsd   xmm1, xmm1                  ; y*y
    addsd   xmm0, xmm1                  ; x*x + y*y
    sqrtsd  xmm0, xmm0                  ; sqrt(...)
    ret

Nombre completo: matematicas::Vector::modulo

Tabla Resumen¶

Característica	Sintaxis	Efecto
Declarar namespace	`namespace nombre { }`	Crea espacio
Activar todo	`using namespace nombre;`	Todo accesible directamente
Activar uno	`using nombre::item;`	Solo ese item accesible
Acceso completo	`nombre::item`	Acceso explícito
Anidado	`namespace n1 { namespace n2 {} }`	Niveles: `n1::n2::item`
Anónimo	`namespace { }`	Interno al archivo
Inline	`inline namespace n { }`	Embebido en padre
Alias	`namespace alias = nombre;`	Nombre corto

Comparación: C vs C++¶

Headers Estándar¶

C	C++ (global)	C++ (namespace std)
`stdio.h`	`stdio.h`	`cstdio`
`stdlib.h`	`stdlib.h`	`cstdlib`
`string.h`	`string.h`	`cstring`
`math.h`	`math.h`	`cmath`

Ejemplo:

#include <stdio.h>   // C: printf en espacio global
#include <cstdio>    // C++: std::printf

// C style (global)
printf("Hello\n");

// C++ style (namespace)
std::printf("Hello\n");

Conclusión para Reversing¶

Lo Visible¶

✅ Nombres completos con namespace

std::cout
proyecto::funcion
math::Vector::calcular

✅ Variables con prefijo

int namespace1::x
int namespace2::x

Lo Invisible¶

❌ using namespace (solo sintaxis fuente) ❌ Distinción activo/inactivo (todo es explícito) ❌ inline namespace (se aplana)

Enfoque Práctico¶

Observar prefijos namespace:: en nombres
Identificar bibliotecas por namespace (std, boost, etc.)
Reconstruir organización del código original
Ignorar si algo estaba "activo" (irrelevante en ASM)

Palabras Reservadas¶

namespace
using
inline (para namespaces inline)

Referencias¶

C++ Standard: Namespaces (ISO/IEC 14882)
Effective C++ (Scott Meyers) - Item 57: Use namespaces to prevent name conflicts
cppreference.com/namespace

Espacios con Nombre (Namespaces)¶

Introducción¶

Problema sin Namespaces¶

Solución con Namespaces¶

Espacio Global¶

Declaración y Definición¶

Sintaxis Básica¶

Ejemplo: Puntos 2D vs 3D¶

Formas de Uso¶

1. Acceso Completo (Sin Activar)¶

2. Forma Directiva: using namespace¶

3. Forma Declarativa: using Individual¶

Comparación de Formas¶

Ejemplo Completo 1: Dos Namespaces¶

Código Fuente¶

Análisis a Bajo Nivel¶

Ensamblador¶

Observaciones Clave¶

Espacios Anidados¶

Concepto¶

Ejemplo Completo¶

Análisis a Bajo Nivel¶

Espacios Anónimos¶

Concepto¶

Ejemplo¶

Equivalencia con static¶

Namespace Inline¶

Concepto¶

Ejemplo¶

Namespace Inline Anónimo¶

A Bajo Nivel¶

Alias de Namespaces¶

Sintaxis¶

Ejemplo¶

Namespaces en Múltiples Archivos¶

Concepto¶

Análisis para Reversing¶

Reglas Generales¶

Patrón de Reconocimiento¶

Ejemplo de Análisis¶

Diferencias con/sin using namespace¶

Con using namespace¶

Sin using namespace¶

Buenas Prácticas¶

✅ Recomendado¶

❌ No Recomendado¶

🔍 En Headers¶

Resolución de Conflictos¶

Problema¶

Solución 1: Especificar Namespace¶

Solución 2: Alias¶

Solución 3: using Selectivo¶

Namespaces y Clases¶

Clase dentro de Namespace¶

Uso¶

A Bajo Nivel¶

Tabla Resumen¶

Comparación: C vs C++¶

Headers Estándar¶

Conclusión para Reversing¶

Lo Visible¶

Lo Invisible¶

Enfoque Práctico¶

Palabras Reservadas¶

Referencias¶

2. Forma Directiva: `using namespace`¶

3. Forma Declarativa: `using` Individual¶

Equivalencia con `static`¶

Diferencias con/sin `using namespace`¶

Con `using namespace`¶

Sin `using namespace`¶

Solución 3: `using` Selectivo¶