Passando um std :: array de tamanho desconhecido para uma função

No C ++ 11, como escrever uma função (ou método) que usa um std :: array de tipo conhecido, mas tamanho desconhecido?

// made up example
void mulArray(std::array<int, ?>& arr, const int multiplier) {
    for(auto& e : arr) {
        e *= multiplier;
    }
}

// lets imagine these being full of numbers
std::array<int, 17> arr1;
std::array<int, 6>  arr2;
std::array<int, 95> arr3;

mulArray(arr1, 3);
mulArray(arr2, 5);
mulArray(arr3, 2);

Durante minha pesquisa, encontrei apenas sugestões para usar modelos, mas essas parecem confusas (definições de método no cabeçalho) e excessivas para o que estou tentando realizar.

Existe uma maneira simples de fazer isso funcionar, como faria com arrays simples no estilo C?

Existe uma maneira simples de fazer isso funcionar, como faria com arrays simples no estilo C?

Não. Você realmente não pode fazer isso a menos que torne sua função um modelo de função (ou use outro tipo de contêiner, como um std::vector, conforme sugerido nos comentários à pergunta):

template<std::size_t SIZE>
void mulArray(std::array<int, SIZE>& arr, const int multiplier) {
    for(auto& e : arr) {
        e *= multiplier;
    }
}

Aqui está um exemplo ao vivo .

O tamanho de arrayfaz parte do tipo , então você não pode fazer exatamente o que deseja. Existem algumas alternativas.

O preferido seria usar um par de iteradores:

template <typename Iter>
void mulArray(Iter first, Iter last, const int multiplier) {
    for(; first != last; ++first) {
        *first *= multiplier;
    }
}

Como alternativa, use em vectorvez de array, que permite armazenar o tamanho no tempo de execução, em vez de como parte de seu tipo:

void mulArray(std::vector<int>& arr, const int multiplier) {
    for(auto& e : arr) {
        e *= multiplier;
    }
}

Eu tentei abaixo e funcionou para mim.

#include <iostream>
#include <array>

using namespace std;

// made up example
void mulArray(auto &arr, const int multiplier) 
{
    for(auto& e : arr) 
    {
        e *= multiplier;
    }
}

void dispArray(auto &arr)
{
    for(auto& e : arr) 
    {
        std::cout << e << " ";
    }
    std::cout << endl;
}

int main()
{

    // lets imagine these being full of numbers
    std::array<int, 7> arr1 = {1, 2, 3, 4, 5, 6, 7};
    std::array<int, 6> arr2 = {2, 4, 6, 8, 10, 12};
    std::array<int, 9> arr3 = {1, 1, 1, 1, 1, 1, 1, 1, 1};

    dispArray(arr1);
    dispArray(arr2);
    dispArray(arr3);

    mulArray(arr1, 3);
    mulArray(arr2, 5);
    mulArray(arr3, 2);

    dispArray(arr1);
    dispArray(arr2);
    dispArray(arr3);

    return 0;
}

RESULTADO :

1 2 3 4 5 6 7

2 4 6 8 10 12

1 1 1 1 1 1 1 1 1

3 6 9 12 15 18 21

10 20 30 40 50 60

2 2 2 2 2 2 2 2 2

EDITAR

C ++ 20 inclui provisoriamente std::span

https://en.cppreference.com/w/cpp/container/span

Resposta Original

O que você quer é algo como gsl::span, que está disponível na Biblioteca de Suporte de Diretrizes descrita nas Diretrizes Básicas de C ++:

https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#SS-views

Você pode encontrar uma implementação somente de cabeçalho de código aberto da GSL aqui:

https://github.com/Microsoft/GSL

Com gsl::span, você pode fazer isso:

// made up example
void mulArray(gsl::span<int>& arr, const int multiplier) {
    for(auto& e : arr) {
        e *= multiplier;
    }
}

// lets imagine these being full of numbers
std::array<int, 17> arr1;
std::array<int, 6>  arr2;
std::array<int, 95> arr3;

mulArray(arr1, 3);
mulArray(arr2, 5);
mulArray(arr3, 2);

O problema com std::arrayé que seu tamanho é parte de seu tipo, então você teria que usar um modelo para implementar uma função std::arrayde tamanho arbitrário.

gsl::spanpor outro lado, armazena seu tamanho como informação de tempo de execução. Isso permite que você use uma função não modelo para aceitar uma matriz de tamanho arbitrário. Também aceitará outros contêineres contíguos:

std::vector<int> vec = {1, 2, 3, 4};
int carr[] = {5, 6, 7, 8};

mulArray(vec, 6);
mulArray(carr, 7);

Muito legal, hein?

Com certeza, existe uma maneira simples no C ++ 11 de escrever uma função que recebe um std :: array de tipo conhecido, mas de tamanho desconhecido.

Se não formos capazes de passar o tamanho do array para a função, então, em vez disso, podemos passar o endereço de memória de onde o array começa junto com um segundo endereço de onde o array termina. Posteriormente, dentro da função, podemos usar esses 2 endereços de memória para calcular o tamanho do array!

#include <iostream>
#include <array>

// The function that can take a std::array of any size!
void mulArray(int* piStart, int* piLast, int multiplier){

     // Calculate the size of the array (how many values it holds)
     unsigned int uiArraySize = piLast - piStart;

     // print each value held in the array
     for (unsigned int uiCount = 0; uiCount < uiArraySize; uiCount++)     
          std::cout << *(piStart + uiCount) * multiplier << std::endl;
}

int main(){   

     // initialize an array that can can hold 5 values
     std::array<int, 5> iValues;

     iValues[0] = 5;
     iValues[1] = 10;
     iValues[2] = 1;
     iValues[3] = 2;
     iValues[4] = 4;

     // Provide a pointer to both the beginning and end addresses of 
     // the array.
     mulArray(iValues.begin(), iValues.end(), 2);

     return 0;
}

Saída no console: 10, 20, 2, 4, 8

Isso pode ser feito, mas são necessárias algumas etapas para fazer de forma limpa. Primeiro, escreva um template classque represente um intervalo de valores contíguos. Em seguida, encaminhe uma templateversão que saiba o quão grande arrayé para a Implversão que leva esse intervalo contíguo.

Finalmente, implemente a contig_rangeversão. Observe que for( int& x: range )funciona para contig_range, porque implementei begin()e end()e os ponteiros são iteradores.

template<typename T>
struct contig_range {
  T* _begin, _end;
  contig_range( T* b, T* e ):_begin(b), _end(e) {}
  T const* begin() const { return _begin; }
  T const* end() const { return _end; }
  T* begin() { return _begin; }
  T* end() { return _end; }
  contig_range( contig_range const& ) = default;
  contig_range( contig_range && ) = default;
  contig_range():_begin(nullptr), _end(nullptr) {}

  // maybe block `operator=`?  contig_range follows reference semantics
  // and there really isn't a run time safe `operator=` for reference semantics on
  // a range when the RHS is of unknown width...
  // I guess I could make it follow pointer semantics and rebase?  Dunno
  // this being tricky, I am tempted to =delete operator=

  template<typename T, std::size_t N>
  contig_range( std::array<T, N>& arr ): _begin(&*std::begin(arr)), _end(&*std::end(arr)) {}
  template<typename T, std::size_t N>
  contig_range( T(&arr)[N] ): _begin(&*std::begin(arr)), _end(&*std::end(arr)) {}
  template<typename T, typename A>
  contig_range( std::vector<T, A>& arr ): _begin(&*std::begin(arr)), _end(&*std::end(arr)) {}
};

void mulArrayImpl( contig_range<int> arr, const int multiplier );

template<std::size_t N>
void mulArray( std::array<int, N>& arr, const int multiplier ) {
  mulArrayImpl( contig_range<int>(arr), multiplier );
}

(não testado, mas o design deve funcionar).

Então, em seu .cpparquivo:

void mulArrayImpl(contig_range<int> rng, const int multiplier) {
  for(auto& e : rng) {
    e *= multiplier;
  }
}

Isso tem a desvantagem de que o código que faz um loop sobre o conteúdo do array não sabe (em tempo de compilação) o tamanho do array, o que pode custar a otimização. Tem a vantagem de que a implementação não precisa estar no cabeçalho.

Tenha cuidado ao construir explicitamente um contig_range, pois se você passá-lo um, setele assumirá que os setdados são contíguos, o que é falso, e terá um comportamento indefinido em todo o lugar. Os únicos dois stdcontêineres em que isso funciona são vectore array(e arrays de estilo C, por acaso!). dequeapesar de ser aleatório, o acesso não é contíguo (perigosamente, é contíguo em pequenos pedaços!), listnão é nem perto, e os containers associativos (ordenados e não ordenados) são igualmente não contíguos.

Assim, os três construtores I implementadas quando std::array, std::vectore C-estilo matrizes, que abrange basicamente as bases.

Implementação []é tão fácil assim, e entre for()e []que é mais do que você quer um arraypara, não é?