Ver el código de «cpp/language/dependent name»

No tienes permiso para modificar esta página, por el siguiente motivo:
La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.
Puedes ver y copiar el código fuente de esta página.
{{title|Nombres dependientes}}
{{cpp/language/templates/navbar}}

Dentro de la definición de una {{rlp|templates|plantilla}} (de {{rlp|class template|clase}} y de {{rlp|function template|función}}), el significado de algunas construcciones puede diferir de una instanciación a otra. En particular, los tipos y expresiones pueden depender de tipos de parámetros de plantilla de tipo y valores de parámetros de plantilla que no son de tipos.

{{source|1=
template<typename T>
struct X : B<T> // "B<T>" depende de T
{
    typename T::A* pa; // "T::A" depende de T
                       // (vea a continuación el significado de este uso de "typename")
    
    void f(B<T>* pb)
    {
        static int i = B<T>::i; // "B<T>::i" depende de T
        pb->j++; // "pb->j" depende de T
    }
};
}}

La búsqueda por nombre y el enlace son diferentes para los ''nombres dependientes'' y los ''nombres no dependientes''.

===Reglas de enlace===
Los nombres no dependientes se buscan y vinculan en el punto de definición de la plantilla. Esta vinculación se mantiene incluso si en el punto de instanciación de la plantilla hay una mejor coincidencia: 
{{example
|code=
#include <iostream>

void g(double) { std::cout << "g(double)\n"; }

template<class T>
struct S
{
    void f() const
    {
        g(1); // "g" es un nombre no dependiente, se enlaza ahora
    }
};

void g(int) { std::cout << "g(int)\n"; }

int main()
{
    g(1);  // llama a g(int)

    S<int> s;
    s.f(); // llama a g(double)
}
}}

Si el significado de un ''nombre no dependiente'' cambia entre el contexto de definición y el punto de instanciación de una especialización de plantilla, el programa está mal formado, no se requiere diagnóstico. Esto es posible en las siguientes situaciones:
* un tipo usado en un nombre no dependiente es {{rlp|incomplete type|incompleto}} en el punto de definición pero completo en el punto de instanciación
{{rrev|since=c++17|
* la búsqueda de un nombre en la definición de  plantilla encontró una {{rlp|using declaration|declaración using}}, pero la búsqueda en el ámbito correspondiente en la instanciación no encuentra ninguna declaración porque la declaración using era una expansión de paquete y el paquete correspondiente está vacío
}}
* una instanciación usa un argumento predeterminado o un argumento de plantilla predeterminado que no estaba definido en el punto de definición
* una {{rlp|constant expression|expresión constante}} en el punto de instanciación usa el valor de un objeto constante de tipo enumeración entero o sin ámbito{{rev inl|since=c++11|, el valor de un objeto constexpr, el valor de una referencia, o la definición de una función}}, y ese objeto{{rev inl|since=c++11|/referencia/función}} no estaba definida en el punto de definición
* la plantilla usa una especialización de plantilla de clase no dependiente {{rev inl|since=c++14|o una especialización de plantilla de variable}} en el punto de instanciación, y esta plantilla que usa se crea a partir de una especialización parcial que no se definió en el punto de definición o nombra una especialización explícita que no fue declarada en el punto de definición

La vinculación de ''nombres dependientes'' se pospone hasta que se realice las búsqueda.

===Reglas de búsqueda===
Como se indico en {{rlp|lookup|búsqueda}}, la búsqueda de un nombre dependiente usado en una plantilla se pospone hasta que se conocen los argumentos de plantilla, momento en el cual
* la búsqueda no ADL examina las declaraciones de funciones con enlazado externo que son visibles desde el contexto de ''definición de la plantilla''
* {{rlp|adl|ADL}} examina las declaraciones de funciones con enlazado externo que son visibles desde el contexto de ''definición de plantilla'' o el contexto ''instanciación de plantilla''
(en otras palabras, añadir una nueva declaración de función después de la definición de la plantilla no la hace visible, excepto a través de ADL).

El propósito de esta regla es ayudar a protegerse con las violaciones de la {{rlp|definition#One Definition Rule|ODR (regla de una definición)}} para las instancias de plantilla:
{{source|1=
// una biblioteca externa
namespace E
{
    template<typename T>
    void escribirObjeto(const T& t)
    {
        std::cout << "Valor = " << t << '\n';
    }
}

// unidad de traducción 1:
// El programador 1 quiere permitir que E::escribirObjeto funcione con vector<int>
namespace P1
{
    std::ostream& operator<<(std::ostream& os, const std::vector<int>& v)
    {
        for (int n : v)
            os << n << ' ';
        return os;
    }
    
    void hacerAlgo()
    {
        std::vector<int> v;
        E::escribirObjeto(v); // error: no se encontrará P1::operator<<
    }
}

// unidad de traducción 2:
// El programador 2 quiere permitir que E::escribirObjeto funcione con vector<int>
namespace P2
{
    std::ostream& operator<<(std::ostream& os, const std::vector<int>& v)
    {
        for (int n : v)
            os << n << ':';
        return os << "[]";
    }
    
    void hacerAlgoMas()
    {
        std::vector<int> v;
        E::escribirObjeto(v); // error: no se encontrará P2::operator<<
    }
}
}}

En el ejemplo anterior, si se permitiera la búsqueda no ADL para {{tt|operator<<}} desde el contexto de instanciación, la instanciación de {{c|E::escribirObjeto<vector<int>>}} tendría dos definiciones diferentes: una usando {{c|P1::operator<<}} y otra usando {{c|P2::operator<<}}. Esta violación de ODR puede no detectarse por el enlazador, lo que lleva a que se use uno u otro en ambos casos.

Para hacer que ADL examine un espacio de nombres definido por el usuario, {{tt|std::vector}} debe reemplazarse por una clase definida por el usuario o su tipo de elemento debe ser una clase definida por usuario:
{{source|1=
namespace P1
{
    // si C es una clase definida en el espacio de nombres P1
    std::ostream& operator<<(std::ostream& os, const std::vector<C>& v)
    {
        for (C n : v)
            os << n;
        return os;
    }
    
    void hacerAlgo()
    {
        std::vector<C> v;
        E::escribirObjeto(v); // correcto: se instancia escribirObjeto(std::vector<P1::C>)
                           //     que encuentra P1::operator<< a través de ADL
    }
}
}}

Nota: esta regla hace que sea poco práctico sobrecargar operadores para tipos de la biblioteca estándar:
{{example|code=
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>

// Mala idea: operator en espacio de nombres global, pero sus argumentos están en std::
std::ostream& operator<<(std::ostream& os, std::pair<int, double> p)
{
    return os << p.first << ',' << p.second;
}

int main()
{
    typedef std::pair<int, double> elem_t;
    std::vector<elem_t> v(10);
    std::cout << v[0] << '\n'; // correcto, la búsqueda ordinaria encuentra ::operator<<
    std::copy(v.begin(), v.end(), std::ostream_iterator<elem_t>(std::cout, " "));
    // Error: tanto la búsqueda ordinaria desde el punto de definición de
    // std::ostream_iterator como ADL solo considerarán el espacio de nombres std,
    // y encontrarán muchas sobrecargas de std::operator<<, por lo que realizará la
    // la búsqueda.
    // La resolución de sobrecarga no podrá encontrar operator<< para elem_t
    // en el conjunto encontrado por la búsqueda.
}
}}

Nota: la búsqueda limitada (pero no vinculante) de nombres dependientes también se realiza en el momento de la definición de la plantilla, según se necesite para distinguirlos de los nombres no dependientes y también para determinar si son miembros de la instanciación actual o miembros de una especialización desconocida. La información obtenida por esta búsqueda se puede usar para detectar errores, véase a continuación.

===Tipos dependientes===
Los siguientes tipos son dependientes:
* parámetro plantilla
* un miembro de una ''especialización desconocida'' (ver más abajo)
* una clase/enumeración anidada que es miembro de una ''especialización desconocida'' (ver más abajo)
* una versión calificada cv de un tipo dependiente
* un tipo compuesto construido a partir de una tipo dependiente
* un tipo array cuyo tipo de elemento es dependiente o cuyo límite (si hay) es dependiente de valor
{{rrev|since=c++11|
* un tipo función cuyos parámetros incluyen uno o más {{rlp|parameter pack|paquetes de parámetros}} de función
}}
* un tipo función cuya especificación de excepción es dependiente de valor
* un {{rlp|templates#template-id|identificador de plantilla}} donde
:* el nombre de plantilla es un parámetro de plantilla, o
:* cualquiera de los argumentos de plantilla es dependiente de tipo, o dependiente de valor{{rev inl|since=c++11|, o es una expansión de paquete}} (incluso si el identificador de plantilla se usa sin su lista de argumentos, como {{rlp|injected-class-name|nombre de clase inyectado}})
{{rrev|since=c++11|
* el resultado de {{rlpt|decltype}} aplicado a una expresión dependiente de tipo

El resultado de {{tt|decltype}} aplicado a una expresión dependiente de tipo es un tipo dependiente único. Dos de estos resultado se refieren al mismo tipo solo si sus expresiones son {{rlp|function template#Function template overloading|equivalentes}}.
}}

Nota: un miembro typedef de una instanciación actual solo es dependiente cuando el tipo al que se refiere lo es.


===Expresiones dependientes de tipo===
Las siguientes expresiones son dependientes de tipo:
* una expresión cuya subexpresión es una expresión dependiente de tipo
* {{c|this}}, si la clase es un tipo dependiente.
* una {{rlp|identifiers|expresión id}} que {{rev inl|since=c++20|no es {{rlp|constraints|id de concepto}} y}}
:* contiene un identificador para el cual la búsqueda de nombres encuentra al menos una declaración dependiente
:* contiene un {{rlp|templates#template-id|identificador de plantilla}} dependiente
{{rrev|since=c++11|
:* contiene el identificador especial {{tt|__func__}} (si alguna función adjunta es una plantilla, un miembro que no es una plantilla de una plantilla de clase{{rev inl|since=c++14|, o un lambda genérico}})
}}
:* contiene el nombre de una {{rlp|cast operator|función de conversión}} a un tipo dependiente
:* contiene un especificador de nombre anidado o {{rlp|identifiers|un identificador calificado}} que es miembro de una ''especialización desconocida''
:* nombra un miembro dependiente de la ''instanciación actual'' que es un miembro de datos estático de tipo "array sin límite conocido"
{{rev begin}}
{{rev|since=c++14|
:* contiene un identificador para el cual la búsqueda por nombre encuentra una o más declaraciones de funciones miembro de la instanciación actual declarada con {{rlp|function#Return type deduction|deducción de tipo de retorno}}
}}
{{rev|since=c++17|
:* contiene un identificador para el cual la búsqueda por nombre encuentra una {{rlp|structured binding|declaración de vinculación estructurada}} cuyo inicializador es dependiente de tipo
:* contiene un identificador para el cual la búsqueda por nombre encuentra una parámetro de plantilla de no tipo cuyo tipo contiene el marcador {{tt|auto}}
:* contiene un identificador para el cual la búsqueda por nombre encuentra una variable declarada con tipo que contiene un tipo marcador (por ejemplo, miembro de datos estático {{tt|auto}}), donde el inicializador es dependiente de tipo
}}
{{rev end}}
* cualquier expresión de conversión a un tipo dependiente
* una {{rlp|new|expresión new}} que crea un objeto de un tipo dependiente
* una expresión de acceso a miembro que se refiere a un miembro de la ''instanciación actual'' cuyo tipo es dependiente
* una expresión de acceso a miembro que se refiere a un miembro de una ''especialización desconocida''

{{rrev|since=c++17|
* una {{rlp|fold|expresión de pliegue}}
}}

Nota: los literales, las llamadas a pseudodestructores{{rev inl|since=c++11|, {{rlpt|alignof}}, {{rlpt|noexcept}}}}, {{rlpt|sizeof}}, {{rlpt|typeid}}, {{rlpt|delete}}, y expresiones {{rlpt|throw}} nunca son dependientes de tipo porque los tipos de estas expresiones no pueden serlo.

===Expresiones dependientes de valor===
* una expresión usada en un contexto donde se requiere una {{rlp|constant expression|expresión constante}}, y cuya subexpresión es dependiente de valor
* una {{rlp|identifiers|expresión de identificador}} que
{{rrev|since=c++20|
:* es un {{rlp|constraints|identificador de concepto}} y cualquiera de sus argumentos es dependiente
}}
:* es dependiente de tipo {{mark unreviewed dr|CWG|2109}}
:* es un nombre de un parámetro de plantilla de no tipo
:* nombra un miembro estático de datos que es un miembro dependiente del la ''instanciación actual'' y no está inicializado.
:* nombra una función miembro estática que es un miembro dependiente de la ''instanciación actual''
:* es una constante con un tipo {{rev inl|until=c++11|entero no enumeración}}{{rev inl|since=c++11|literal}}, inicializado a través de una expresión dependiente de valor
* expresiones {{rev inl|since=c++11|{{rlpt|alignof}}, {{rlpt|noexcept}}, }}{{rlpt|sizeof}}, {{rlpt|typeid}} donde el argumento es una expresión dependiente de tipo o un identificador de tipo dependiente
* cualquier expresión de conversión a un tipo dependiente o desde una expresión dependiente de valor
* una expresión address-of donde el argumento es un {{rlp|identifiers|identificador calificado}} que nombra un miembro dependiente de la ''instanciación actual''
* expresión address-of donde el argumento es cualquier expresión que, evaluada como una {{rlp|constant expression|expresión constante}} central, hace referencia a una {{rlp|templates#Templated entity|entidad con plantilla}} que es un objeto de duración de almacenamiento estático {{rev inl|since=c++11|o  de hilo}} o una función miembro.
{{rrev|since=c++17|
* {{rlp|fold|expresión de pliege}}
}}

===Nombres dependientes===
{{todo|the lede from [temp.dep], which is missing (id-expression followed by parenthesized list...}}
{{todo|reword to maybe make it more clear (or at least less intimidating), and while at it, apply {{cwg|591}} }}

===Instanciación actual===
Dentro de una definición de plantilla de clase (incluidas sus funciones miembro y clases anidadas), se pueden deducir algunos nombres para referirse a la ''instanciación actual''. Esto permite que se detecten ciertos errores en el punto de definición, en lugar de la instanciación, y elimina el requisito de los desambiguadores {{tt|typename}} y {{tt|template}} para nombres dependientes, véase a continuación. 

Solo los siguientes nombres pueden hacer referencia a instanciación actual:
* en una definición de plantilla de clase:
:* una clase anidada, un miembro de la plantilla de clase, un miembro de una clase anidada, el nombre de clase inyectada de la plantilla, el nombre de clase inyectada de una clase anidada.
* en una definición de plantilla de clase principal o en la definición de sus miembros: 
:* nombre de la plantilla de clase seguido de la lista de argumentos de plantilla (o una especialización de plantilla de alias equivalente) para la plantilla principal donde cada argumento es equivalente (definido a continuación) a su parámetro correspondiente.
* en la definición de una clase anidada o plantilla de clase:
:* nombre de la clase anidada usada como un miembro de la instanciación actual.
* en la definición de una especialización parcial o de un miembro de una especialización parcial:
:* el nombre de la plantilla de clase seguido de la lista de argumentos de plantilla para la especialización parcial, donde cada argumento es equivalente a su parámetro correspondiente.

Un argumento de plantilla es equivalente a un parámetro de plantilla si
* para un {{rlp|template parameters#Type template parameter|parámetro de tipo}}, el argumento de plantilla denota el mismo tipo que el parámetro de plantilla.
* para un {{rlp|template parameters#Non-type template parameter|parámetro de no tipo}}, el argumento de plantilla es un {{rlp|identifiers|identificador}} que denomina una variable que es equivalente al parámetro de plantilla. Una variable es equivalente a un parámetro de plantilla si
:* tiene el mismo tipo que el parámetro de plantilla (ignorando la calificación cv) y
:* su inicializador consta de un único identificador que nombre al parámetro de la plantilla o, recursivamente, dicha variable.

{{source|1=
template<class T>
class A
{
    A* p1;      // A es la instanciación actual
    A<T>* p2;   // A<T> es la instanciación actual
    ::A<T>* p4; // ::A<T> es la instanciación actual
    A<T*> p3;   // A<T*> no es la instanciación actual
    
    class B
    {
        B* p1;                 // B es la instanciación actual
        A<T>::B* p2;           // A<T>::B es la instanciación actual
        typename A<T*>::B* p3; // A<T*>::B no es la instanciación actual
    };
};

template<class T>
class A<T*>
{
    A<T*>* p1; // A<T*> es la instanciación actual
    A<T>* p2;  // A<T> no es la instanciación actual
};

template<int I>
struct B
{
    static const int mi_I = I;
    static const int mi_I2 = I + 0;
    static const int mi_I3 = mi_I;
    static const long mi_I4 = I;
    static const int mi_I5 = (I);
    
    B<mi_I>* b1;  // B<mi_I> es la instanciación actual:
                  //   mi_I tiene el mismo tipo que I,
                  //   y se inicializa solamente con I
    B<mi_I2>* b2; // B<mi_I2> no es la instanciación actual:
                  //   I + 0 no es un identificador único
    B<mi_I3>* b3; // B<mi_I3> es la instanciación actual:
                  //   mi_I3 tiene el mismo tipo que I,
                  //   y se inicializa solamente con mi_I (que es equivalente a I)
    B<mi_I4>* b4; // B<mi_I4> no es la instanciación actual:
                  //   el tipo de mi_I4 (long) no es el mismo que el tipo de I (int)
    B<mi_I5>* b5; // B<mi_I5> no es la instanciación actual:
                  //   (I) no es un identificador único
};
}}

Tenga en cuenta que una clase base puede ser la instanciación actual si una clase anidada deriva de su plantilla de clase adjunta. Las clases base que son dependientes de tipo pero no son la instanciación actual son ''clases base dependientes'':
{{source|1=
template<class T>
struct A
{
    typedef int M;
    
    struct B
    {
        typedef void M;
        
        struct C;
    };
};

template<class T>
struct A<T>::B::C : A<T>
{
    M m; // correcto, A<T>::M
};
}}

Un nombre se clasifica como miembro de la instanciación actual si es
* un nombre no calificado que se encuentra mediante una {{rlp|unqualified lookup|búsqueda no calificada}} en la instanciación actual o en su base no dependiente.
* un {{rlp|qualified lookup|nombre calificado}}, si el calificador (el nombre a la izquierda de {{ttb|::}}) nombra a la instanciación actual y la búsqueda encuentra el nombre en la instanciación actual o en su base no dependiente.
* un nombre usado en una expresión de acceso a miembro de clase ({{tt|y}} en {{tt|x.y}} o {{tt|xp->y}}), donde la expresión de objeto ({{tt|x}} o {{tt|*xp}}) es la instanciación actual y la búsqueda encuentra el nombre de la instanciación actual o en su base no dependiente

{{source|1=
template<class T>
class A
{
    static const int i = 5;
    
    int n1[i];       // i se refiere a un miembro de la instanciación actual
    int n2[A::i];    // A::i se refiere a un miembro de la instanciación actual
    int n3[A<T>::i]; // A<T>::i se refiere a un miembro de la instanciación actual
    
    int f();
};

template<class T>
int A<T>::f()
{
    return i; // i se refiere a un miembro de la instanciación actual
}
}}

Los miembros de la instanciación actual pueden ser tanto dependientes como no dependientes.

Si la búsqueda de un miembro de la instanciación actual da un resultado diferente entre el punto de instanciación y el punto de definición, la búsqueda es ambigua. Tenga en cuenta, sin embargo, que cuando se utiliza un nombre de miembro, no se convierte automáticamente en una expresión de acceso a miembro de clase, solo las expresiones de acceso de miembro explícitas indican miembros de la instanciación actual:
{{source|1=
struct A { int m; };
struct B { int m; };

template<typename T>
struct C : A, T
{
    int f() { return this->m; } // encuentra A::m en el contexto de definición de plantilla
    int g() { return m; }       // encuentra A::m en el contexto de definición de plantilla
};

template int C<B>::f(); // error: encuentra A::m y B::m

template int C<B>::g(); // correcto: la transformación a sintaxis de acceso a miembro de clase
                        // no se produce en el contexto de definición de plantilla
}}

===Especializaciones desconocidas===
Dentro de una definición de plantilla, se deduce que ciertos nombres pertenecen a una ''especialización desconocida'', en particular,

* un {{rlp|qualified lookup|nombre calificado}}, si cualquier nombre que aparece a la izquierda de {{ttb|::}} es un ''tipo dependiente'' que no es un miembro de la ''instanciación actual''
* un {{rlp|qualified lookup|nombre calificado}}, cuyo calificador es la ''instanciación actual'', y el nombre no se encuentra en la instanciación actual o cualquiera de sus clases base no dependientes, y hay una clase base dependiente
* un nombre de un miembro en una expresión de acceso a miembro de clase (la {{tt|y}} en {{tt|x.y}} o {{tt|xp->y}}), si el tipo de la expresión de objeto ({{tt|x}} o {{tt|*xp}}) es un ''tipo dependiente'' y no es la ''instanciación actual''
* un nombre de un miembro en una expresión de acceso a miembro de clase (la {{tt|y}} en {{tt|x.y}} o {{tt|xp->y}}), si el tipo de la expresión de objeto  ({{tt|x}} o {{tt|*xp}}) es la ''instanciación actual'', y el nombre no se encuentra en la instanciación actual o en cualquiera de sus clases base no dependientes, y hay una clase base dependiente

{{source|1=
template<typename T>
struct Base {};

template<typename T>
struct Derivada : Base<T>
{
    void f()
    {
        // Derivada<T> se refiere a la instancia actual
        // no hay un 'tipo_desconocido' en la instanciación actual,
        // pero hay una base dependiente (Base<T>)
        // Por lo tanto, tipo_desconocido es miembro de una especialización desconocida
        typename Derivada<T>::tipo_desconocido z;
    }
};

template<>
struct Base<int> // esta especialización lo proporciona
{
    typedef int tipo_desconocido; 
};
}}


Esta clasificación permite detectar los siguientes errores en el punto de definición de la plantilla (en lugar de la instanciación):

* Si alguna definición de plantilla tiene un {{rlp|qualified lookup|nombre calificado}} en el que el calificador se refiere a la ''instanciación actual'' y el nombre no es miembro de la ''instanciación actual'' ni de una ''especialización desconocida'', el programa está mal formado (no requiere diagnostico) incluso si la plantilla nunca se instancia.
{{source|1=
template<class T>
class A
{
    typedef int tipo;
    
    void f()
    {
        A<T>::tipo i; // correcto: 'tipo' es un miembro de la instanciación actual
        typename A<T>::otro j; // Error:
        
        // 'otro' no es un miembro de la instanciación actual
        // y no es miembro de una especialización desconocida
        // porque A<T> (que denomina la instanciación actual),
        // no tiene bases dependientes para que 'otro' esté oculto.
    }
};
}}
* Si alguna definición de plantilla tiene una expresión de acceso a miembro donde la expresión de objeto es la ''instanciación actual'', pero el nombre no es un miembro de la ''instanciación actual'' ni un miembro de una ''especialización desconocida'', el programa está mal formado, incluso si la plantilla nunca se instancia.

Los miembros de una especialización desconocida siempre son dependientes, y se buscan y vinculan en el punto de instanciación como todos los nombres dependientes (ver arriba).

{{anchor|typename disambiguator}}
===El desambiguador {{c|typename}} para nombres dependientes===

En una declaración o definición de una plantilla, incluyendo la plantilla de alias, un nombre que no es miembro de la ''instanciación actual'' y es dependiente de un parámetro de plantilla no se considera un tipo a no ser que se use la palabra clave {{c|typename}} o a menos que ya se estableciera como nombre de tipo, por ejemplo: con una declaración typedef o al usarse para nombrar una clase base.

{{example|code=
#include <iostream>
#include <vector>

int p = 1;

template<typename T>
void foo(const std::vector<T> &v)
{
    // std::vector<T>::const_iterator es un nombre dependiente,
    typename std::vector<T>::const_iterator it = v.begin();

    // sin 'typename', lo siguiente se analiza como la multiplicación 
    // de la variable miembro dependiente de tipo 'const_iterator' 
    // y alguna variable 'p'. Dado que hay una 'p' global visible
    // en este punto, esta definición de plantilla compila.
    std::vector<T>::const_iterator* p; 

    typedef typename std::vector<T>::const_iterator iter_t;
    iter_t * p2; // iter_t es un nombre dependiente, pero se sabe que es un nombre de tipo
}

template<typename T>
struct S
{
    typedef int value_t; // miembro de la instanciación actual
    
    void f()
    {
        S<T>::value_t n{}; // S<T> es dependiente, pero no se necesita 'typename'
        std::cout << n << '\n';
    }
};

int main()
{
    std::vector<int> v;
    foo(v); // la instanciación de plantilla falla: no hay una variable miembro
            // llamada 'const_iterator' en el tipo std::vector<int>
    S<int>().f();
}
}}

La palabra clave {{c|typename}} solamente se puede usar de esta manera antes de nombres calificados (por ejemplo, {{c|T::x}}), pero los nombres no necesitan ser dependientes.

Se usa la {{rlp|qualified lookup|búsqueda habitual de nombres calificados}} para el identificador con el prefijo {{tt|typename}}. A diferencia del caso con el {{rlp|elaborated type specifier|especificador de tipo elaborado}}, las reglas de búsqueda no cambian a pesar del calificador:

{{source|1=
struct A // A tiene una variable anidada X y un tipo anidado struct X
{
    struct X {};
    int X;
};

struct B
{
    struct X {}; // B tiene un tipo anidado struct X
};

template<class T>
void f(T t)
{
    typename T::X x;
}

void foo()
{
    A a;
    B b;
    f(b); // correcto: instancia f<B>, T::X se refiere a B::X
    f(a); // error: no se puede instanciar f<A>:
          // porque la búsqueda de nombres calificada para A::X encuentra el miembro de datos
}
}}

La palabra clave {{c|typename}} se puede usar incluso fuera de las plantillas.
{{source|1=
#include <vector>

int main()
{
    // Ambos correctos (después de resolver CWG 382)
    typedef typename std::vector<int>::const_iterator iter_t;
    typename std::vector<int> v;
}
}}

{{rrev|since=c++20|
En algunos contextos, sólo es válido que aparezcan nombres de tipos. En estos contextos, se supone que un nombre calificado dependiente nombra un tipo y no se requiere {{c|typename}}:
* Un nombre calificado que se usa como un {{rlp|declarations#Specifiers|especificador de declaración}} en la {{spar|secuencia-de-especificadorers-de-declaración}} (de nivel superior) de:
:* una {{rlp|declarations#Simple declaration|declaración simple}} o una {{rlp|function#Function definition|definición de función}} en el ámbito de espacio de nombres;
:* una {{rlp|class#Member specification|declaración de miembro de clase}};
:* una {{rlp|function#Parameter list|declaración de parámetro}} en una {{rlp|class#Member specification|declaración de miembro de clase}} (incluyendo la declaración de funciones friend), fuera de los argumentos predeterminados;
:* una {{rlp|function#Parameter list|declaración de parámetro}} de un {{rlp|function|declarador para una función o plantilla de función}} cuyo nombre es calificado, fuera de los argumentos predeterminados;
:* una {{rlp|function#Parameter list|declaración de parámetro}} de una {{rlp|lambda|expresión lambda}} fuera de los argumentos predeterminados;
:* una declaración de parámetro de una {{rlp|constraints#Requires expressions|expresión requiere}};
:* el tipo en la declaración de un {{rlp|template parameters#Non-type template parameter|parámetro de plantilla de no tipo}};
* Un nombre calificado que aparece en un ''{{rlp|type#Type naming|identificador de tipo}}'', donde el ''identificador de tipo'' más interno es:
:* el {{spar|tipo}} es una {{rlp|new|expresión new}} que no tiene el tipo entre paréntesis;
:* el {{spar|identificador de tipo}} en una {{rlp|type alias|declaración de alias}};
:* un {{rlp|function|tipo de retorno final}},
:* un {{rlp|template parameters#Type template parameter|argumento predeterminado de un parámetro de plantilla de tipo}}, o
:* el {{spar|identificador de tipo}} de un {{rlpt|static_cast}}, {{rlpt|dynamic_cast}}, {{rlpt|const_cast}}, o {{rlpt|reinterpret_cast}}.
}}

{{anchor|template disambiguator}}
===El desambiguador {{c|template}} para nombres dependientes===
De manera similar, en una definición de plantilla, un nombre dependiente que no es miembro de la  ''instanciación actual'' no se considera un nombre de plantilla a menos que se use la palabra clave de desambiguación {{c|template}} o a menos que ya se haya establecido como nombre de plantilla:

{{example|code=
template<typename T>
struct S
{
    template<typename U>
    void foo() {}
};

template<typename T>
void bar()
{
    S<T> s;
    s.foo<T>();          // error: < analizado como operador menor que
    s.template foo<T>(); // correcto
}
}}

La palabra clave {{c|template}} sólo se puede usar de esta manera después de los operadores {{c|::}} (resolución de ámbito), {{c|->}} (acceso a miembro a través de puntero), y {{c|.}} (acceso a miembro), los siguientes son ejemplos válidos:

* {{c|T::template foo<X>();}}
* {{c|s.template foo<X>();}}
* {{c|this->template foo<X>();}}
* {{c|typename T::template iterator<int>::value_type v;}}

Como en el caso de {{c|typename}}, el prefijo {{c|template}} se permite incluso si el nombre no es dependiente o el uso no aparece en el ámbito de una plantilla.

Incluso si el nombre a la izquierda de {{ttb|::}} se refiere a un espacio de nombres, se permite el desambiguador de plantilla:
{{source|1=
template<typename>
struct S {};

::template S<void> q; // permitido, pero innecesario
}}

{{rrev|until=c++23|
Debido a las reglas especiales para la {{rlp|unqualified lookup|búsqueda de nombres no calificados}} para nombres de plantilla en expresiones de acceso a miembro, cuando aparece un nombre de plantilla no dependiente en una expresión de acceso a miembro (después de {{c|->}} o {{c|.}}), el desambiguador no es necesario si hay una plantilla de {{rev inl|since=c++11|clase o alias}} con el mismo nombre encontrado mediante la búsqueda ordinaria en el contexto de la expresión. {{rev inl|until=c++11|Si embargo, si la plantilla encontrada por búsqueda en el contexto de la expresión difiere de la encontrada en el contexto de la clase, el programa está mal formado}}

{{source|1=
template<int>
struct A { int valor; };

template<class T>
void f(T t)
{
    t.A<0>::valor; // La búsqueda ordinaria de A encuentra una plantilla de clase.
                   // A<0>::valor denomina un miembro de la clase A<0>
    // t.A < 0;    // Error: '<' se trata como el comienzo de una lista de argumentos de plantilla
}
}}
}}

===Informes de defectos===
{{dr list begin}}
{{dr list item|wg=cwg|dr=206|std=C++98|before=No se especificó en que punto se aplican las restriccione semánticas cuando<br> un tipo usado en un nombre no dependiente está incompleto en el punto en<br> que se define una plantilla pero está completo en el punto en que se realiza<br> una instanciación|after=el programa está mal formado, y, en<br> este caso, no se requiere  diagnostico}}
{{dr list item|wg=cwg|dr=224|std=C++98|before=la definición de tipos dependientes se basó en la forma del nombre en lugar de<br> la búsqueda|after=definición renovada}}
{{dr list item|wg=cwg|dr=382|std=C++98|before=el desambiguador {{c|typename}} sólo estaba permitido en el ámbito de una plantilla|after=permitido también fuera de las<br> plantillas}}
{{dr list item|wg=cwg|dr=468|std=C++98|before=el desambiguador {{c|template}} sólo estaba permitido en el ámbito de una plantilla|after=también se permite fuera de las<br> plantillas}}
{{dr list item|wg=cwg|dr=502|std=C++98|before=no se especificó si las enumeraciones anidadas son dependientes|after=dependientes como las clases anidadas}}
{{dr list item|wg=cwg|dr=1047|std=C++98|before=las expresiones {{tt|typeid}} nunca son dependientes de valor|after=dependientes de valor si<br>el operando es dependiente de tipo}}
{{dr list item|wg=cwg|dr=1160|std=C++98|before=no se especificó si un nombre se refiere a la instanciación actual<br>cuando aparece un id de plantilla que coincide con una plantilla principal<br>o especialización parcial en la definición de un miembro de plantilla|after=especificado}}
{{dr list item|wg=cwg|dr=1413|std=C++98|before=el miembro de datos estático no inicializado, la función miembro estática y<br>la dirección del miembro de una plantilla de clase no se registró como<br>dependientes de valor|after=registrado}}
{{dr list item|wg=cwg|dr=1471|std=C++98|before=un tipo anidado de una base no dependiente de la instanciación actual<br> era dependiente|after=no es dependiente}}
{{dr list item|wg=cwg|dr=1850|std=C++98|before=la lista de casos en los que el significado puede cambiar entre<br>el contexto de definición y el punto de instanciación estaba incompleta|after=se completa}}
{{dr list item|wg=cwg|dr=1929|std=C++98|before=no estaba claro si el desambiguador {{c|template}} puede seguir<br> a un {{tt|::}} donde el nombre a su izquierda se refiere a un espacio de nombres|after=permitido}}
{{dr list item|wg=cwg|dr=2100|std=C++98|before=la dirección de un miembro de datos estático de la plantilla<br>de clase no figuraba como dependiente del valor|after=ahora figura}}
{{dr list item|wg=cwg|dr=2276|std=C++98|before=un tipo de función cuya especificación de excepción<br>es dependiente de valor no era un tipo dependiente|after=si es}}
{{dr list item|wg=cwg|dr=2307|std=C++98|before=un parámetro de plantilla de no tipo entre paréntesis utilizado<br>como argumento de plantilla era equivalente a ese parámetro de plantilla|after=ya no es equivalente}}
{{dr list item|wg=cwg|dr=2457|std=C++11|before=un tipo de función con paquete de parámetros de función no era un tipo dependiente|after=si es}}
{{dr list end}}

{{langlinks|en|ja|ru|zh}}
Plantillas usadas en esta página:
Volver a cpp/language/dependent name.
cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/language/dependent name»

Navegación

Herramientas
