কোনও ফাংশনে অজানা আকারের একটি স্টাডি :: অ্যারে পাস করা

Question 1

সি ++ ১১-এ, আমি কীভাবে একটি ফাংশন (বা পদ্ধতি) লিখতে যাব যে একটি স্ট্যান্ড :: জ্ঞাত প্রকারের অ্যারে নেবে কিন্তু অজানা আকারের?

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

আমার অনুসন্ধানের সময় আমি কেবলমাত্র টেমপ্লেটগুলি ব্যবহার করার জন্য পরামর্শ পেয়েছি, তবে এগুলি অগোছালো বলে মনে হচ্ছে (শিরোনামে পদ্ধতির সংজ্ঞা) এবং আমি কী সম্পাদন করার চেষ্টা করছি তার জন্য অতিরিক্ত।

এই কাজটি করার সহজ উপায় কি আছে, যেমন একসাথে সি-স্টাইলের অ্যারে রয়েছে?

Question 2

এই কাজটি করার সহজ উপায় কি আছে, যেমন একসাথে সি-স্টাইলের অ্যারে রয়েছে?

না। আপনি যদি নিজের ফাংশনটিকে কোনও ফাংশন টেম্পলেট না করে থাকেন তবে (বা std::vectorপ্রশ্নের মন্তব্যে প্রস্তাবিত কোনও ধরণের ধারক ব্যবহার না করা) আপনি আসলেই এটি করতে পারবেন না :

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

এখানে একটি সরাসরি উদাহরণ ।

Question 3

আকার 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;
    }
}

Question 4

সম্পাদনা

সি ++ 20 অন্তর্ভুক্ত অন্তর্ভুক্ত std::span

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

আসল উত্তর

আপনি যা চান তা হ'ল এটি gsl::span, যা সি ++ কোর গাইডলাইনে বর্ণিত গাইডলাইন সহায়তা লাইব্রেরিতে পাওয়া যায়:

https://github.com/isocpp/CppCoreGuidlines/blob/master/CppCoreGuidlines.md#SS- ভিউ

আপনি এখানে জিএসএল-এর একটি মুক্ত-উত্স শিরোনাম-কেবল বাস্তবায়ন পেতে পারেন:

https://github.com মাইক্রোসফট / জিএসএল

সহ 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);

খুব সুন্দর, হাহ?

Question 5

আমি নীচে চেষ্টা করেছি এবং এটি কেবল আমার জন্য কাজ করেছে।

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

Question 6

অবশ্যই, একটি ফাংশন লিখতে সি ++ 11 এ একটি সহজ উপায় রয়েছে যা পরিচিত ধরণের স্ট্যান্ড :: অ্যারে নেবে তবে অজানা আকার।

যদি আমরা ফাংশনে অ্যারের আকারটি পাস করতে না পারি তবে তার পরিবর্তে, আমরা অ্যারে যেখানে শেষ হয় তার ২ য় ঠিকানা সহ অ্যারে শুরু হয় তার মেমরি ঠিকানাটি পাস করতে পারি। পরে, ফাংশনের অভ্যন্তরে, আমরা অ্যারেটির আকার গণনা করতে এই 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

Question 7

এটি করা যেতে পারে তবে পরিষ্কারভাবে কয়েক ধাপ নিতে হবে। প্রথমে এমন একটি লিখুন 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;
  }
}

এটির এমন নেতিবাচক দিক রয়েছে যা অ্যারের সামগ্রীর উপরে লুপ করে যে কোডটি জানে না (সংকলন করার সময়) অ্যারেটি কত বড়, যা অপ্টিমাইজেশন ব্যয় করতে পারে। এটির সুবিধাটি রয়েছে যে বাস্তবায়নটি শিরোনামে থাকতে হবে না।

একটি পরিষ্কারভাবে নির্মাণের বিষয়ে সতর্কতা অবলম্বন করুন contig_range, যদি আপনি এটি পাস করেন তবে setএটি ধরে নেওয়া হবে যে setডেটাটি সংলগ্ন, যা মিথ্যা, এবং সমস্ত জায়গায় অপরিজ্ঞাত আচরণ করে do মাত্র দুটি stdপাত্রে যে এই কাজের জন্য নিশ্চিত করা হয় হয় vectorএবং array(এবং C-শৈলী অ্যারে যখনই যা ঘটে তখনই!)। dequeএলোমেলো অ্যাক্সেস থাকা সত্ত্বেও এটি সংশ্লেষযোগ্য নয় (বিপজ্জনকভাবে, এটি ছোট অংশগুলিতে মজাদার!), listএমনকি খুব কাছাকাছিও নয়, এবং সহযোগী (অর্ডারযুক্ত এবং অর্ডারযুক্ত) পাত্রেও সমানভাবে স্বতন্ত্র নয়।

তাই তিন কনস্ট্রাকটর আমি কোথায় বাস্তবায়িত std::array, std::vectorএবং C-শৈলী অ্যারে, যা মূলত ঘাঁটি জুড়ে।

বাস্তবায়নও []সহজ এবং এর মধ্যে for()এবং []এটি যা আপনি চান তার বেশিরভাগই arrayতাই না?