ส่งผ่านอาร์เรย์ std :: ที่ไม่ทราบขนาดไปยังฟังก์ชัน

ใน 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 ธรรมดาหรือไม่?

ไม่คุณไม่สามารถทำได้จริง ๆ เว้นแต่คุณจะทำให้ฟังก์ชันของคุณเป็นเทมเพลตฟังก์ชัน(หรือใช้คอนเทนเนอร์ประเภทอื่นเช่น an 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;
    }
}

แก้ไข

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ในทางกลับกันเก็บขนาดเป็นข้อมูลรันไทม์ สิ่งนี้ช่วยให้คุณใช้ฟังก์ชันที่ไม่ใช่เทมเพลตหนึ่งฟังก์ชันเพื่อยอมรับอาร์เรย์ของขนาดที่กำหนด นอกจากนี้ยังยอมรับคอนเทนเนอร์อื่น ๆ ที่ต่อเนื่องกัน:

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

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

สวยดีใช่มั้ย?

ฉันลองด้านล่างและมันก็ใช้ได้ผลสำหรับฉัน

#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 1

3 6 9 12 15 18 21

10 20 30 40 50 60

2 2 2 2 2 2 2 2 2

แน่นอนมีวิธีง่ายๆใน 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

ซึ่งสามารถทำได้ แต่ต้องใช้ขั้นตอนไม่กี่ขั้นตอนในการทำ ขั้นแรกเขียน a template classที่แสดงถึงช่วงของค่าที่ต่อเนื่องกัน จากนั้นส่งต่อtemplateเวอร์ชันที่ทราบว่ามีขนาดใหญ่เพียงarrayใดไปยังImplเวอร์ชันที่ใช้ช่วงที่ต่อเนื่องกันนี้

สุดท้ายใช้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;
  }
}

สิ่งนี้มีข้อเสียตรงที่โค้ดที่วนซ้ำเนื้อหาของอาร์เรย์ไม่ทราบ (ในขณะคอมไพล์) ว่าอาร์เรย์มีขนาดใหญ่เพียงใดซึ่งอาจทำให้ต้นทุนเพิ่มประสิทธิภาพได้ มีข้อดีคือการนำไปใช้งานไม่จำเป็นต้องอยู่ในส่วนหัว

ระวังการสร้าง a อย่างชัดเจนcontig_rangeราวกับว่าคุณส่งผ่านมันsetจะถือว่าsetข้อมูลนั้นต่อเนื่องกันซึ่งเป็นเท็จและมีพฤติกรรมที่ไม่ได้กำหนดไว้ทั่วทุกที่ มีเพียงสองstdคอนเทนเนอร์เท่านั้นที่รับประกันว่าจะใช้งานได้คือvectorและarray(และอาร์เรย์สไตล์ C เมื่อเกิดขึ้น!) dequeแม้ว่าจะเป็นการเข้าถึงแบบสุ่มก็ไม่ได้อยู่ติดกัน (อันตรายมันอยู่ติดกันเป็นชิ้นเล็ก ๆ !) listไม่ได้อยู่ใกล้กันและคอนเทนเนอร์ที่เชื่อมโยงกัน (เรียงลำดับและไม่เรียงลำดับ) ก็ไม่ติดกัน

ดังนั้นสามก่อสร้างผมดำเนินการที่std::array, std::vectorและ C สไตล์อาร์เรย์ซึ่งโดยทั่วไปครอบคลุมฐาน

การดำเนินการ[]เป็นเรื่องง่ายเช่นกันและระหว่างfor()และ[]ที่เป็นที่สุดของสิ่งที่คุณต้องการarrayสำหรับไม่ได้หรือไม่