Início / coding / Perguntas / 77673096
Accepted
比尔盖子
Asked: 2023-12-17 10:02:06 +0800 CST

Você pode usar uma lista de inicialização com chaves como argumento de modelo (padrão)?

  • 772

Preciso definir um modelo C++ que aceite várias coordenadas 3D como parâmetros. Quando todas as dimensões destas coordenadas são definidas como variáveis ​​inteiras separadas, a lista de parâmetros se tornaria excessivamente longa - 3 coordenadas precisam de 9 parâmetros, o que torna o modelo difícil de usar.

Portanto, é altamente desejável declarar os modelos de forma a usar matrizes em tempo de compilação. Seus argumentos padrão também devem ser declarados diretamente no local da declaração do modelo como valores, em vez de nomes de variáveis.

Após algumas experiências, para minha surpresa, descobri que o GCC 13 aceitará o seguinte programa C++ com std=c++20:

#include <cstdio>
#include <array>

template <
    std::array<int, 3> offset = {0, 0, 0}
>
struct Array
{
    void operator() (int i, int j, int k) 
    {
        printf("(%d, %d, %d)\n", i + offset[0], j + offset[1], k + offset[2]);
    }
};

int main(void)
{
    Array arr_default;
    arr_default(0, 0, 0);

    Array<{1, 1, 1}> arr;
    arr(0, 0, 0);

    return 0;
}

No entanto, o clang 18 rejeita a lista de inicialização com chaves como inválida:

test2.cpp:5:30: error: expected expression
    5 |         std::array<int, 3> offset = {0, 0, 0}
      |                                     ^
test2.cpp:17:8: error: no viable constructor or deduction guide for deduction of template arguments of 'Array'
   17 |         Array arr_default;
      |               ^
test2.cpp:7:8: note: candidate template ignored: couldn't infer template argument 'offset'
    7 | struct Array
      |        ^
test2.cpp:7:8: note: candidate function template not viable: requires 1 argument, but 0 were provided
    7 | struct Array
      |        ^~~~~
test2.cpp:20:8: error: expected expression
   20 |         Array<{1, 1, 1}> arr;
      |               ^
3 errors generated.

Pergunta

  1. É realmente um programa C++ legal? Se for, que sintaxe devo usar para convencer o clang a aceitá-lo? Caso contrário, devo relatar um bug do GCC por aceitá-lo inquestionavelmente?

  2. Existe uma forma alternativa e mais compatível de atingir meus objetivos? O uso std::arraynão é necessário, quaisquer outros métodos com efeito equivalente também são aceitáveis.

c++

2 respostas

  1. Best Answer

    Problema

    Este é o CWG 2450 e/ou CWG 2049 e , embora a gramática atual não permita isso, propõe-se que seja permitido/válido pelo motivo mencionado abaixo. Isso significa que o Gcc está apenas permitindo preventivamente a sintaxe . Do CWG 2450:

    Como os parâmetros de modelo sem tipo agora podem ter tipos de classe, parece fazer sentido permitir uma lista de inicialização entre chaves como argumento de modelo, mas a gramática não permite isso.

    (ênfase minha)

    Caso você esteja se perguntando como a gramática atual não permite isso, em temp.name#1 :

    template-argument:
    constant-expression
    type-id
    id-expression

    E como {1, 1, 1}não é nenhuma das três construções listadas acima, não pode ser usado como argumento de modelo de acordo com as regras gramaticais atuais.

    Existe uma forma alternativa e mais compatível de atingir meus objetivos?

    Solução

    Você pode escrever explicitamente std::arrayantes da lista de inicialização entre chaves, conforme mostrado abaixo:

    #include <cstdio>
#include <array>

template <
//------------------------------vvvvvvvvvv----------->added this
    std::array<int, 3> offset = std::array{0, 0, 0}
>
struct Array
{
    void operator() (int i, int j, int k) 
    {
        printf("(%d, %d, %d)\n", i + offset[0], j + offset[1], k + offset[2]);
    }
};

int main(void)
{
    Array arr_default;
    arr_default(0, 0, 0);
//--------vvvvvvvvvv------------------->added this
    Array<std::array{1, 1, 1}> arr;
    arr(0, 0, 0);

    return 0;
}

    Observação

    Observe também que o clang trunk também começa a aceitar o programa enquanto o gcc e o msvc já o aceitam em versões anteriores.

    • 11

  2. No C++ atual, eu esperaria que seu código fosse parecido com isto:

    #include <iostream>
#include <format>
#include <vector>

// using namespace std; <== unlearn to use this (risk of nameclashes in big projects)

// this is how you declare a structure/class template
template<typename type_t> 
struct vector_3d_t
{
    type_t x;
    type_t y;
    type_t z;
};

// make new strong types (don't use `using` for this)
struct position_3d_t : public vector_3d_t<int> {};
struct velocity_3d_t : public vector_3d_t<int> {};

position_3d_t update(const position_3d_t& position, const velocity_3d_t& velocity)
{
    return position_3d_t 
    { 
        position.x + velocity.x,
        position.y + velocity.y,
        position.z + velocity.z 
    };
}

// Overload operator<< so ostreams (like std::cout) know
// how to format one vector_3d_t
template <typename type_t>
std::ostream& operator<<(std::ostream& os, const vector_3d_t<type_t>& vector)
{
    os << std::format("[{},{},{}]", vector.x, vector.y, vector.x );
    return os;
}


int main()
{
    // C++'s vector which is dynamically resizable array
    // and this is how you can initialize multiple positios 
    // in a few lines of code. 
    std::vector<position_3d_t> positions
    {{
        {1,1,1}, 
        {2,2,2}, 
        {3,3,3}
    }};

    // learn about range base for loops 
    // and use them when you don't need indices
    for(const auto& position : positions)
    {
        std::cout << position << "\n";
    }
}
    • -2

relate perguntas