Le passage d'un std::array de taille inconnue à une fonction

La taille de la array est partie du type d', de sorte que vous ne pouvez pas faire tout ce que vous voulez. Il ya un couple de solutions de rechange.

Préféré serait 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;
    }
}

Alternativement, utilisez vector au lieu de la matrice, ce 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;
    }
}

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

Si nous sommes incapables de passer la taille du tableau à la fonction, au lieu de cela, nous pouvons passer l'adresse de la mémoire de l'endroit où le tableau commence avec une 2ème adresse de l'endroit où le tableau se termine. Plus tard, à l'intérieur de la fonction, nous pouvons utiliser ces 2 adresses de 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;
}

À la sortie de la Console: 10, 20, 2, 4, 8

Cela peut être fait, mais il ne prend que quelques étapes à faire proprement. Tout d'abord, écrire un template class qui représente une plage contiguë de valeurs. Puis le transférer à un template version qui sait comment taille les array est à la Impl version qui prend cette plage contiguë.

Enfin, de mettre en œuvre la contig_range version. Notez que for( int& x: range ) fonctionne pour contig_range, parce que j'ai mis en place 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 );
}

(pas testé, mais le design devrait fonctionner).

Puis, dans votre .cpp fichier:

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

Cela a l'inconvénient que le code qui effectue une boucle sur le contenu de la matrice ne sait pas (au moment de la compilation) la taille du tableau, ce qui pourrait l'optimisation des coûts. Il a l'avantage de la mise en œuvre n'a pas à être dans l'en-tête.

Être prudent au sujet de construire explicitement un contig_range, comme si vous passer un set il suppose que le set données est contiguë, ce qui est faux, et ne pas défini le comportement de tous sur la place. Les deux seuls std conteneurs que cela est garanti pour fonctionner sur sont vector et array (et C-style des tableaux, comme il arrive!). deque en dépit d'être à accès aléatoire n'est pas contiguë (dangereusement, il est contiguë en petits morceaux!), list n'est même pas proche, et le associatif (triées ou non) les conteneurs sont également non contigus.

De sorte que les trois constructeurs j'ai mis en place où std::array, std::vector et de style C tableaux, qui couvre l'essentiel des bases.

La mise en œuvre de [] est facile, et entre for() et [] qui est le plus de ce que vous voulez un array pour, n'est-ce pas?