El misterio de la plantilla de dos fases "roto" instanciación en Microsoft Visual c

declaración de problemas:

usuarios comúnmente expresa preocupaciones que Microsoft Visual C (MSVC) luchan con la implementación correctamente de dos plantillas. ¿Qué aspectos específicos del mecanismo no funcionan como se esperan?

en segundo plano:

La instancia de la plantilla de dos fases implica una verificación de sintaxis inicial que MSVC supuestamente realiza. Sin embargo, surgen dudas sobre si esta verificación verifica si los nombres utilizados dentro de las plantillas se declaran adecuadamente.

explicación:

de hecho, la verificación de sintaxis inicial de MSVC está limitada en el alcance. No verifica la presencia de nombres declarados, lo que lleva a problemas de compilación cuando los nombres carecen de declaraciones adecuadas.

para ilustrar esto, considere el siguiente ejemplo:

int foo(void*);

template struct S {
  S() { int i = foo(0); }
};

void foo(int);

int main() {
  S s;
}

Un compilador que cumple con el estándar resolvería la llamada foo (0) durante la primera fase y la ataría a foo (void*). Sin embargo, MSVC pospone este proceso a la segunda fase, que es incorrectamente vinculante foo (0) a foo (int) y resulta en un error.

Además, la implementación de MSVC de la segunda fase se desvía de la especificación del lenguaje de dos maneras:

1. se extiende el lookup no ADLS con las declaraciones de las declaraciones durante las segundas acumuladas durante la segunda. fase.
2. se resuelve incorrectamente expresiones dependientes, como bar (t) en el código a continuación, a declaraciones que solo son visibles durante la segunda fase.

namespace N {
  struct S {};
}

void bar(void *) {}

template <typename T> void foo(T *t) {
  bar(t);
}

void bar(N::S *s) {}

int main() {
  N::S s;
  foo(&s);
}

En ambos casos, el comportamiento de MSVC contraviene la separación especificada entre la primera y segunda fases de la instancia de la plantilla. Esta implementación incorrecta persiste en Visual Studio 2015.