Início / coding / Perguntas / 78575975
Accepted
PiotrNycz
Asked: 2024-06-04 22:14:57 +0800 CST

É necessário que os modelos de classe sejam instanciados para usar apenas ponteiro ou referência a eles? [duplicado]

  • 772

Ao usar apenas ponteiros/referências para std::variant<T...>definir de T...onde parte de T é declarada apenas para frente - tenho esse problema que não consigo nem usar ponteiros nem referências para isso std::variant- porque suas classes bases queriam ser instanciadas - e exigem std::is_default_constructibleoutras características.

Veja código de exemplo:

#include <variant>

struct A;
struct B;
using AB = std::variant<A,B>;
AB* ab();

template <typename T>
void usePointer(T*){}


int main() {
    // fails to compile because std::variant gets instantiated here!
    usePointer(ab());
}

Para simplificar o exemplo - isto é o que acontece como vejo:

struct A;
struct B;

template <typename T>
void usePointer(T*){}


template <bool> class SomeBase {};

template <typename T>
struct Some : SomeBase<std::is_default_constructible_v<T>>
{};

Some<A>* someA(); 

int main() {
    // this will not compile - because  this
    // SomeBase<std::is_default_constructible_v<T>>
    // does not compile - because A is unknown
    usePointer(someA());
}

/opt/compiler-explorer/gcc-14.1.0/include/c++/14.1.0/type_traits: In instantiation of 'constexpr const bool std::is_default_constructible_v<A>':
<source>:12:29:   required from 'struct Some<A>'
   12 | struct Some : SomeBase<std::is_default_constructible_v<T>>
      |                        ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:21:23:   required from here
   21 |     usePointer(someA());
      |                       ^
/opt/compiler-explorer/gcc-14.1.0/include/c++/14.1.0/type_traits:3385:54: error: invalid use of incomplete type 'struct A'
 3385 |   inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
      |                                                      ^~~~~~~~~~~~~~~~~~~~~~~
<source>:3:8: note: forward declaration of 'struct A'
    3 | struct A;
      |        ^
Compiler returned: 1

Todos os 3 compiladores (gcc, clang, msvc) se comportam/rejeitam da mesma maneira - veja: https://godbolt.org/z/5cjf1Pv4d

A pergunta: isso está correto? Para mim, isso é realmente um bug - seja nas implementações dos compiladores ou no padrão - porém não consigo encontrar nada no padrão que exija esse comportamento.

O "engraçado" é que quando o modelo de classe também é declarado adiante - tudo funciona. Quero dizer - este código é aceito por todos os compiladores:

struct A;

template <typename T>
void usePointer(T*){}

template <typename T> struct Some;

Some<A>* someA(); 

int main() {
    usePointer(someA());
}
c++

1 respostas

  1. Best Answer

    Isso ocorre porque std::variantprecisa ser instanciado para ADL: pode haver um friend void usePointer(std::variant<A, B>*)declarado dentro std::variantque ele teria que usar, então o modelo precisa ser instanciado (causando erro porque std::variantprecisa que seus tipos sejam completos quando for instanciado).

    A solução é não usar ADL:

    template <typename T>
void usePointer(T*){}

namespace ns {
template <typename T>
void usePointer(T*){}
}

int main() {
    // Can't be "unqualified-id ( expression-list[opt] )"
    (usePointer)(ab());
    ::usePointer(ab());
    ns::usePointer(ab());
}

    https://eel.is/c++draft/basic.lookup.argdep#1

    Quando a expressão postfix em uma chamada de função é unqualified-id e a pesquisa não qualificada pelo nome no unqualified-id não encontra nenhum

    • declaração de um membro da classe, ou
    • declaração de função que habita um escopo de bloco, ou
    • declaração que não é de uma função ou modelo de função

    então a pesquisa pelo nome também inclui o resultado da pesquisa dependente de argumento em um conjunto de namespaces associados que depende dos tipos de argumentos (e para argumentos de modelo de modelo, o namespace do argumento de modelo), conforme especificado abaixo.

    usePointernão encontra um membro de classe, função de escopo de bloco ou modelo de não função/função.

    https://eel.is/c++draft/basic.lookup.argdep#3.4

    Se Tfor um ponteiro Uou uma matriz de U, suas entidades associadas serão aquelas associadas a U.

    Então T = std::variant<A, B>*,U = std::variant<A, B>

    https://eel.is/c++draft/basic.lookup.argdep#3.2.sentence-1

    Se Tfor um tipo de classe (incluindo uniões), suas entidades associadas são: a própria classe; a classe da qual faz parte, se houver; e, se for um tipo completo, suas classes base diretas e indiretas.

    (Antes de CWG2857 , isso tecnicamente não precisava instanciar a classe. Mas esse não é o comportamento esperado porque nenhuma friendfunção nos modelos poderia ser encontrada antes de serem instanciadas implicitamente em outro lugar, e isso era um defeito padrão)

    Então a classe precisa ser do tipo completa para ver suas bases.

    https://eel.is/c++draft/temp.inst#2

    A menos que uma especialização de modelo de classe seja uma especialização declarada, a especialização de modelo de classe é instanciada implicitamente quando a especialização é referenciada em um contexto que requer um tipo de objeto completamente definido ou quando a integridade do tipo de classe afeta a semântica do programa.

    Então temos que instanciá-lo.

    É também por isso que seu exemplo struct A; é compilado: não é um modelo, portanto não precisa ser instanciado.

    Se você fez isso, a integridade afetará o programa:

    struct A;

void f(auto*) { std::puts("default"); }
void g(auto* p) { f(p); }
int main() {
    g(static_cast<A*>(nullptr));
}
struct A {
    friend void f(A*) { std::puts("friend"); }
};

    ... seu programa se tornaria NDR mal formado ( https://eel.is/c++draft/temp.dep.res#temp.point-7.sentence-4 )

    • 5

relate perguntas