不明なサイズのstd :: arrayを関数に渡す

C ++ 11では、既知の型でサイズが不明なstd :: arrayを受け取る関数（またはメソッド）をどのように記述すればよいでしょうか？

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

検索中にテンプレートを使用するための提案しか見つかりませんでしたが、それらは面倒（ヘッダーのメソッド定義）で、私が達成しようとしていることに対して過度に見えます。

単純なCスタイルの配列の場合のように、これを機能させる簡単な方法はありますか？

単純なCスタイルの配列の場合のように、これを機能させる簡単な方法はありますか？

いいえ。関数を関数テンプレートにしない限り（またはstd::vector、質問へのコメントで提案されているように、のような別の種類のコンテナーを使用しない限り）、実際にそれを行うことはできません。

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

これがライブの例です。

大きさは、arrayあるタイプの一部なので、あなたが望むものを非常に行うことはできません。いくつかの選択肢があります。

イテレータのペアを取得することをお勧めします。

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

または、vector配列の代わりに使用します。これにより、型の一部としてではなく、実行時にサイズを格納できます。

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

以下を試しましたが、うまくいきました。

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

出力：

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

編集する

C ++ 20には暫定的に含まれる std::span

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

元の回答

あなたが欲しいのはのようなものgsl::spanで、C ++コアガイドラインで説明されているガイドラインサポートライブラリで入手できます。

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

GSLのオープンソースのヘッダーのみの実装は、次の場所にあります。

https://github.com/Microsoft/GSL

ではgsl::span、これを行うことができます：

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

の問題std::arrayは、そのサイズがそのタイプの一部であるためstd::array、任意のサイズの関数を実装するためにテンプレートを使用する必要があることです。

gsl::span一方、そのサイズはランタイム情報として保存されます。これにより、1つの非テンプレート関数を使用して、任意のサイズの配列を受け入れることができます。他の隣接するコンテナも受け入れます。

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

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

かっこいいですよね？

絶対に、C ++ 11には、既知の型でサイズが不明なstd :: arrayを受け取る関数を作成する簡単な方法があります。

配列のサイズを関数に渡すことができない場合は、代わりに、配列が始まる場所のメモリアドレスと、配列が終わる場所の2番目のアドレスを渡すことができます。その後、関数内で、これらの2つのメモリアドレスを使用して配列のサイズを計算できます。

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

コンソールで出力： 10、20、2、4、8

これは可能ですが、きれいに行うにはいくつかの手順が必要です。まず、template class連続する値の範囲を表すaを記述します。次に、この連続する範囲をとるバージョンに、templateどれほど大きいかを知っているバージョンを転送します。arrayImpl

最後に、contig_rangeバージョンを実装します。注for( int& x: range )のために働くcontig_range私が実装するので、begin()およびend()とポインタはイテレータです。

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

（テストされていませんが、設計は機能するはずです）。

次に、.cppファイルで：

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

これには、配列の内容をループするコードが配列の大きさ（コンパイル時に）を知らないため、最適化にコストがかかるという欠点があります。これは、実装がヘッダーにある必要がないという利点があります。

を明示的に作成するcontig_range場合は注意してください。これを渡すとset、setデータが連続していると見なされ、偽であり、どこでも未定義の動作を行うためです。stdこれが機能することが保証されている唯一の2つのコンテナーはvector、and array（およびCスタイルの配列です）。 dequeランダムアクセスであるにもかかわらず、隣接していない（危険なことに、小さなチャンクで連続している！）か、list近接しておらず、連想（順序付けと順序付けなし）コンテナーも同様に隣接していません。

したがって、私が実装した3つのコンストラクタwhere std::array、std::vectorおよび基本的にベースをカバーするCスタイルの配列。

実装は[]、同様に簡単である、との間for()と[]、あなたは何をしたいのほとんどであるarrayため、それはないですか？