Passer un std :: array de taille inconnue à une fonction

En C ++ 11, comment pourrais-je écrire une fonction (ou une méthode) qui prend un std :: array de type connu mais de taille inconnue?

// 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);

Au cours de ma recherche, je n'ai trouvé que des suggestions d'utilisation de modèles, mais celles-ci semblent désordonnées (définitions de méthode dans l'en-tête) et excessives pour ce que j'essaie d'accomplir.

Existe-t-il un moyen simple de faire fonctionner cela, comme on le ferait avec des tableaux simples de style C?

Existe-t-il un moyen simple de faire fonctionner cela, comme on le ferait avec des tableaux simples de style C?

Non. Vous ne pouvez vraiment pas faire cela à moins de faire de votre fonction un modèle de fonction (ou d'utiliser un autre type de conteneur, comme un std::vector, comme suggéré dans les commentaires de la question):

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

Voici un exemple en direct .

La taille du arrayfait partie du type , vous ne pouvez donc pas faire tout ce que vous voulez. Il existe plusieurs alternatives.

Il serait préférable de prendre une paire d'itérateurs:

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

Sinon, utilisez vectorau lieu de array, qui vous permet de stocker la taille au moment de l'exécution plutôt que dans le cadre de son type:

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

J'ai essayé ci-dessous et cela a fonctionné pour moi.

#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;
}

PRODUCTION :

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

ÉDITER

C ++ 20 inclut provisoirement std::span

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

Réponse originale

Ce que vous voulez, c'est quelque chose comme gsl::span, qui est disponible dans la bibliothèque de prise en charge des lignes directrices décrite dans les lignes directrices de base C ++:

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

Vous pouvez trouver une implémentation open-source de la GSL uniquement en-tête ici:

https://github.com/Microsoft/GSL

Avec gsl::span, vous pouvez faire ceci:

// 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);

Le problème avec std::arrayest que sa taille fait partie de son type, vous devez donc utiliser un modèle pour implémenter une fonction qui prend une std::arraytaille arbitraire.

gsl::spand'autre part, stocke sa taille en tant qu'informations d'exécution. Cela vous permet d'utiliser une fonction non-modèle pour accepter un tableau de taille arbitraire. Il acceptera également d'autres conteneurs contigus:

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

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

Assez cool, hein?

Absolument, il existe un moyen simple en C ++ 11 d'écrire une fonction qui prend un std :: array de type connu, mais de taille inconnue.

Si nous ne pouvons pas transmettre la taille du tableau à la fonction, alors à la place, nous pouvons transmettre l'adresse mémoire de l'endroit où le tableau commence avec une deuxième adresse de l'endroit où le tableau se termine. Plus tard, à l'intérieur de la fonction, nous pouvons utiliser ces 2 adresses mémoire pour calculer la taille du tableau!

#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;
}

Sortie à la console: 10, 20, 2, 4, 8

Cela peut être fait, mais il faut quelques étapes pour le faire proprement. Tout d'abord, écrivez un template classqui représente une plage de valeurs contiguës. Ensuite, transférez une templateversion qui connaît la taille arrayde la Implversion qui prend cette plage contiguë.

Enfin, implémentez la contig_rangeversion. Notez que cela for( int& x: range )fonctionne pour contig_range, car j'ai implémenté begin()et end()et les pointeurs sont des itérateurs.

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 );
}

(non testé, mais la conception devrait fonctionner).

Ensuite, dans votre .cppdossier:

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

Cela a l'inconvénient que le code qui boucle sur le contenu du tableau ne sait pas (au moment de la compilation) la taille du tableau, ce qui pourrait coûter l'optimisation. Il présente l'avantage que l'implémentation ne doit pas nécessairement figurer dans l'en-tête.

Faites attention à ne pas construire explicitement a contig_range, comme si vous le transmettez a setcela supposera que les setdonnées sont contiguës, ce qui est faux, et fera un comportement indéfini partout. Les deux seuls stdconteneurs sur lesquels cela est garanti de fonctionner sont vectoret array(et les tableaux de style C, en l'occurrence!). dequebien que l'accès aléatoire ne soit pas contigu (dangereusement, il est contigu par petits morceaux!), listn'est même pas proche, et les conteneurs associatifs (ordonnés et non ordonnés) sont également non contigus.

Donc, les trois constructeurs que j'ai implémentés où std::array, std::vectoret les tableaux de style C, qui couvrent essentiellement les bases.

La mise en œuvre []est également facile, et entre for()et []c'est ce que vous recherchez array, n'est-ce pas?