Início / coding / Perguntas / 79490890
Accepted
hanshenrik
Asked: 2025-03-07 07:07:37 +0800 CST

Como deduzir automaticamente o tamanho, mas ser explícito sobre o tipo de std::array?

  • 772

Como você faz o compilador deduzir automaticamente o tamanho e, ao mesmo tempo, ser explícito sobre o tipo em um std::array?

por Como você deduz o tamanho de um std::array? a partir do C++17 você pode deduzir automaticamente ambos com

    std::array a{1, 2, 3};

sendo equivalente a

    std::array<int, 3> a{1, 2, 3};

mas eu quero ser explícito sobre o tipo, mas não o tamanho, eu essencialmente quero

std::array<uint64_t> a{1, 2, 3};

mas essa sintaxe exata resulta em

prog.cc:15:20: error: wrong number of template arguments (1, should be 2)
   15 | std::array<uint64_t> a{1, 2, 3};
      |                    ^
c++

2 respostas

  1. Best Answer

    Desde C++20 você pode usar std::to_array(não confundir com std::experimental::make_array).

    Exemplo de cppreference :

    // creates a constexpr array of string_view's  
constexpr auto w1n = std::to_array<std::string_view>({
    "Mary", "Patricia", "Linda", "Barbara", "Elizabeth", "Jennifer"
});

    A função auxiliar é necessária, porque a dedução de argumento de template de classe (CTAD) é tudo ou nada. Apenas std::array a{1, 2, 3};deduz argumentos de template, std::array<int> a{1, 2, 3};não (portanto é um erro claro).

    Se você estiver preso ao C++17, a possível implementação (link acima) deve ser facilmente adaptável para funcionar também antes do C++20.

    Note que std::to_arrayna verdade requer que você passe um array de Ts no estilo c (é assim que ele deduz o tamanho). O array no estilo c pode ser construído na hora a partir de uma lista de inicializadores como no exemplo acima. O que você realmente gostaria de ter é isto:

    decltype(std::to_array<uint64_t>({1, 2, 3}) a{1, 2, 3};

    Não conheço uma maneira mais direta que evite as etapas intermediárias.

    Note que também há um guia de dedução para std::arrayque visa fornecer uma alternativa para o acima mencionado std::experimental::make_array. Embora ele não possa deduzir o tipo de elementos quando você pretende que os inicializadores sejam convertidos implicitamente. O guia usa o primeiro elemento para deduzir o tipo de elementos, mas também requer que todos os inicializadores sejam do mesmo tipo. Portanto, isso funciona:

    std::array a{1, 2, 3};  // OK

    Mas isso não:

    std::array b{ uint64_t{1}, 2, 3}; // deduction guide uses first element...
                                 // but implicitly also all the others

    Você tem que ser explícito:

    std::array b{ uint64_t{1}, uint64_t{2}, uint64_t{3}};  // OK :-/
    • 7

  2. A resposta de @463035818_is_not_an_ai parece ser a melhor maneira, use std::to_array(). mas quando não temos c++>=20, podemos criar algo muito semelhante com um modelo,

    template <typename T, typename... Args>
constexpr auto array2(Args... args) -> std::array<T, sizeof...(args)> {
    return {static_cast<T>(args)...}; // Explicitly cast each argument to T
}

auto a = array2<uint64_t>(1, 2, 3);  
// should be equivalent to std::array<uint64_t, 3) a{1, 2, 3};
// technically equivalent to std::array<uint64_t, 3> a{ static_cast<uint64_t>(1), static_cast<uint64_t>(2), static_cast<uint64_t>(3) };

    caixa de varinha: https://wandbox.org/permlink/397gBYvppFAbxSRC

    parece funcionar para c++>=11.

    • 2

relate perguntas