Início / coding / Perguntas / 79151212
Accepted
Eljay
Asked: 2024-11-03 01:29:51 +0800 CST

A deterioração do ponteiro do array pode ser suprimida ou acomodada?

  • 772

Gostaria de ter uma sobrecarga de função em que um caso de uso passa o argumento não-matriz por ponteiro, e o outro caso de uso passa o argumento C-matriz por referência.

Infelizmente, a passagem de um argumento de matriz C seleciona ambas as funções candidatas porque o decaimento do ponteiro da matriz C deve estar no mesmo nível de consideração, tornando a situação ambígua.

#include <iostream>

static void foo(int* p) {
    std::cout << "int* -> " << *p << "\n";
}

static void foo(int (&a)[4]) {
    std::cout << "int[4] -> "
        << a[0] << " "
        << a[1] << " "
        << a[2] << " "
        << a[3] << "\n";
}

int main() {
    int array[4]{ 10, 20, 30, 40 };
    foo(array); // error: call to 'foo' is ambiguous
    foo(array + 3);
}

Atualmente estou usando esta solução alternativa. Não estou satisfeito com esta solução alternativa.

static void foo(int (*a)[4]) { /*...*/ }

...que seria chamado via...

    foo(&array);

A alternativa de alterar a passagem por ponteiro para passagem por referência a ponteiro void foo(int*& p)impediria chamá-lo por, foo(array + 3)já que é um rvalue.

Existe outra abordagem (ou modelo mágico) que poderia esclarecer as duas situações?

O contexto é preferencialmente C++17, mas se uma solução decente puder ser expressa em C++20 ou posterior, isso ainda seria interessante.

(Problema XY?) O contexto original era a passagem de argumento de um ponteiro ou array como um parâmetro de construtor de classe. O contexto original é uma tentativa de fazer um "ponteiro gordo", como o Miracle Pointer do Google, que é um substituto drop-in de ponteiro de um ponteiro bruto regular, mas contém informações de span e offset e verificações de paranoia (o que incorre em sobrecarga adicional de tempo de execução). Tentei simplificar o exemplo para o caso de reprodução saliente e mínimo.

ATUALIZAÇÃO (respondendo ao comentário): por fim, gostaria que ele também suportasse e distinguisse a const int[4]e a const int*também.

c++

2 respostas

  1. Best Answer

    Despachante com if constexpr (std::is_arrayobras.

    #include <iostream>
#include <type_traits>

static void fooin(int* p) {
    std::cout << "int* -> " << *p << "\n";
}

static void fooinarr(int (&a)[4]) {
    std::cout << "int[4] -> "
        << a[0] << " "
        << a[1] << " "
        << a[2] << " "
        << a[3] << "\n";
}

template<typename T>
static void foo(T &&a) {
    if constexpr (std::is_array_v<std::remove_reference_t<T>>) {
        fooinarr(std::forward<T>(a));
    } else {
        fooin(std::forward<T>(a));
    }
}

int main() {
    int array[4]{ 10, 20, 30, 40 };
    foo(array); // error: call to 'foo' is ambiguous
    foo(array + 3);
}

    ou o mesmo:

    template<typename T, std::enable_if_t<std::is_array_v<std::remove_reference_t<T>>, int> = 0>
static void foo(T &&a) {
        fooinarr(std::forward<T>(a));
}

template<typename T, std::enable_if_t<!std::is_array_v<std::remove_reference_t<T>>, int> = 0>
static void foo(T &&a) {
        fooin(std::forward<T>(a));
}
    • 3

  2. Infelizmente, a passagem de um argumento de matriz C seleciona ambas as funções candidatas

    Então, você deve artificialmente piorar o construtor não array. A maneira mais simples já foi oferecida em um comentário por @user17732522. Mas se por algum motivo isso não funcionar para você, aqui vai uma abordagem mais antiga: introduza uma conversão definida pelo usuário.

    template <typename T>
struct RawPtr
{
    [[gnu::always_inline]] constexpr RawPtr(T* ptr)
     : m_ptr(ptr)
    {
    }

    T*      m_ptr;
};

template <typename T>
struct FatPtr
{
    FatPtr(RawPtr<T> p);
    
    template <size_t N>
    FatPtr(T (&p)[N]);
};

template <typename T>
FatPtr(T*) -> FatPtr<T>;

int main()
{
    int         arr[5] = {};
    const char  carr[3] = {};

    FatPtr      t1(arr);
    FatPtr      t2(arr + 3);
    FatPtr      t3(carr);
    FatPtr      t4(carr + 1);
}

    Exemplo ao vivo: https://godbolt.org/z/1o9KT833x

    • 1

relate perguntas