ইনিশিয়াল_লিস্ট এবং মুভি শব্দার্থক

Question 1

আমি কি উপাদানগুলির বাইরে সরানোর অনুমতি দিচ্ছি std::initializer_list<T>?

#include <initializer_list>
#include <utility>

template<typename T>
void foo(std::initializer_list<T> list)
{
    for (auto it = list.begin(); it != list.end(); ++it)
    {
        bar(std::move(*it));   // kosher?
    }
}

যেহেতু std::intializer_list<T>বিশেষ সংকলক মনোযোগ প্রয়োজন এবং সি ++ স্ট্যান্ডার্ড লাইব্রেরির সাধারণ ধারকগুলির মতো মূল্য শব্দার্থবিজ্ঞান নেই, তাই আমি দুঃখিত ও জিজ্ঞাসার চেয়ে নিরাপদ থাকব।

Question 2

না, এটি ইচ্ছাকৃতভাবে কাজ করবে না; আপনি এখনও কপি পাবেন। আমি এতে অবাক হয়েছি, যেহেতু আমি ভেবেছিলাম যে initializer_listতারা না হওয়া অবধি অস্থায়ী সংস্থাগুলির ব্যবস্থা রাখার জন্য অস্তিত্ব ছিল move।

beginএবং ফিরে আসার endজন্য , সুতরাং আপনার কোডের ফলাফল - একটি অপরিবর্তনীয় মূল্যের রেফারেন্স। এই জাতীয় অভিব্যক্তি অর্থবহ থেকে সরানো যায় না। এটি টাইপের কোনও ফাংশন প্যারামিটারে আবদ্ধ হবে কারণ মূল্যবোধগুলি লভ্যালু রেফারেন্সগুলিতে আবদ্ধ হয় এবং আপনি এখনও অনুলিপি শব্দার্থবিজ্ঞান দেখতে পাবেন।initializer_listconst T *moveT const &&T const &

সম্ভবত এর কারণ তাই সংকলক initializer_listস্ট্যাটিক্যালি-ইনিশিয়েলাইজড ধ্রুবক তৈরি করতে বেছে নিতে পারে , তবে মনে হয় এটির ধরণটি তৈরি করা পরিষ্কার করা ভাল initializer_listবা const initializer_listসংকলকটির বিবেচনার ভিত্তিতে, সুতরাং ব্যবহারকারী কোনও constজবাবদিহি করতে বা পরিবর্তনযোগ্য কিনা তা জানেনা থেকে ফলাফল beginএবং end। তবে এটি কেবল আমার পেটের অনুভূতি, সম্ভবত আমি ভুল হওয়ার কোনও ভাল কারণ রয়েছে।

আপডেট: কেবল স্থানান্তরিত প্রকারের সমর্থনের জন্য আমি একটি আইএসও প্রস্তাব লিখেছি initializer_list। এটি শুধুমাত্র প্রথম খসড়া, এবং এটি এখনও কোথাও বাস্তবায়িত হয়নি, তবে সমস্যার আরও বিশ্লেষণের জন্য আপনি এটি দেখতে পারেন can

Question 3

bar(std::move(*it));   // kosher?

আপনার ইচ্ছা মতো নয় Not আপনি কোনও constবস্তুকে সরিয়ে নিতে পারবেন না । এবং std::initializer_listশুধুমাত্র constএর উপাদানগুলিতে অ্যাক্সেস সরবরাহ করে। ধরণ তাই itহয় const T *।

আপনার কল করার প্রয়াসের std::move(*it)ফলে কেবলমাত্র একটি এল-মান হবে। IE: একটি অনুলিপি

std::initializer_listস্থির মেমরি রেফারেন্স । ক্লাসটি এটাই। আপনি স্থির মেমরি থেকে সরাতে পারবেন না , কারণ চলাচলে বোঝানো হয় এটি পরিবর্তন করা। আপনি কেবল এটি থেকে অনুলিপি করতে পারেন।

Question 4

এটি উল্লিখিত হিসাবে কাজ করবে না, কারণ list.begin()টাইপ আছে const T *, এবং ধ্রুবক বস্তু থেকে আপনি সরানোর কোনও উপায় নেই। ভাষা ডিজাইনাররা সম্ভবত এটি তৈরি করেছিলেন যাতে প্রাথমিককরণের তালিকাগুলিকে উদাহরণস্বরূপ স্ট্রিং ধ্রুবকগুলির জন্য অন্তর্ভুক্ত থাকতে পারে, যেখান থেকে এটি সরানো অনুচিত।

তবে আপনি যদি এমন পরিস্থিতিতে থাকেন যে আপনি যদি জানেন যে প্রারম্ভিক তালিকার মধ্যে মূল্যের ভাব রয়েছে (বা আপনি ব্যবহারকারীকে সেগুলি লিখতে বাধ্য করতে চান) তবে একটি কৌশল আছে যা এটি কার্যকর করবে (সুমেন্টের উত্তরের দ্বারা অনুপ্রেরণা পেয়েছিলাম) এটি, তবে সমাধানটি এর চেয়ে সহজতর উপায়)। আপনি প্রয়োজন initialiser তালিকা সঞ্চিত উপাদান হতে না Tমান, কিন্তু যে encapsulate মান T&&। তারপরেও যদি সেই মানগুলি নিজেরাই constযোগ্য হয় তবে তারা এখনও একটি পরিবর্তনযোগ্য মূল্য পুনরুদ্ধার করতে পারে।

template<typename T>
  class rref_capture
{
  T* ptr;
public:
  rref_capture(T&& x) : ptr(&x) {}
  operator T&& () const { return std::move(*ptr); } // restitute rvalue ref
};

এখন initializer_list<T>যুক্তি ঘোষণার পরিবর্তে আপনি একটি initializer_list<rref_capture<T> >যুক্তি ঘোষণা করুন । এখানে একটি দৃ concrete় উদাহরণ রয়েছে, std::unique_ptr<int>স্মার্ট পয়েন্টারগুলির একটি ভেক্টরকে জড়িত করে, যার জন্য কেবল পদার্থবিজ্ঞানের সংজ্ঞা দেওয়া হয় (যাতে এই বিষয়গুলি নিজেরাই আর কোনও প্রাথমিকের তালিকায় সংরক্ষণ করা যায় না); তবুও নীচের প্রারম্ভক তালিকাটি সমস্যা ছাড়াই সংকলন করে।

#include <memory>
#include <initializer_list>
class uptr_vec
{
  typedef std::unique_ptr<int> uptr; // move only type
  std::vector<uptr> data;
public:
  uptr_vec(uptr_vec&& v) : data(std::move(v.data)) {}
  uptr_vec(std::initializer_list<rref_capture<uptr> > l)
    : data(l.begin(),l.end())
  {}
  uptr_vec& operator=(const uptr_vec&) = delete;
  int operator[] (size_t index) const { return *data[index]; }
};

int main()
{
  std::unique_ptr<int> a(new int(3)), b(new int(1)),c(new int(4));
  uptr_vec v { std::move(a), std::move(b), std::move(c) };
  std::cout << v[0] << "," << v[1] << "," << v[2] << std::endl;
}

একটি প্রশ্নের উত্তরের দরকার আছে: যদি প্রাথমিকের তালিকার উপাদানগুলি সত্য মূল্য থাকে (উদাহরণস্বরূপ তারা xvalue হয়) তবে ভাষাটি কি নিশ্চিত করে যে সংশ্লিষ্ট টেম্পোরারিগুলির আজীবন তারা যে বিন্দুতে ব্যবহৃত হয়েছে সেখানে প্রসারিত হবে? সত্যই, আমি মনে করি না যে প্রমিতের 8.5 প্রাসঙ্গিক বিষয়টি এই বিষয়টিকে মোটেই সম্বোধন করে। যাইহোক, ১.৯: ১০ পড়লে মনে হবে প্রাসঙ্গিক পূর্ণ-এক্সপ্রেশনটি সব ক্ষেত্রেই ইনিশিয়ালার তালিকার ব্যবহারকে অন্তর্ভুক্ত করে, সুতরাং আমি মনে করি যে মূল্যবোধের রেফারেন্সগুলি ঝুঁকির কোনও আশঙ্কা নেই।

Question 5

আমি ভেবেছিলাম এটি একটি কাজের জন্য একটি যুক্তিসঙ্গত প্রারম্ভিক বিন্দু প্রস্তাব দেওয়া শিক্ষণীয় হতে পারে।

মন্তব্য ইনলাইন।

#include <memory>
#include <vector>
#include <array>
#include <type_traits>
#include <algorithm>
#include <iterator>

template<class Array> struct maker;

// a maker which makes a std::vector
template<class T, class A>
struct maker<std::vector<T, A>>
{
  using result_type = std::vector<T, A>;

  template<class...Ts>
  auto operator()(Ts&&...ts) const -> result_type
  {
    result_type result;
    result.reserve(sizeof...(Ts));
    using expand = int[];
    void(expand {
      0,
      (result.push_back(std::forward<Ts>(ts)),0)...
    });

    return result;
  }
};

// a maker which makes std::array
template<class T, std::size_t N>
struct maker<std::array<T, N>>
{
  using result_type = std::array<T, N>;

  template<class...Ts>
  auto operator()(Ts&&...ts) const
  {
    return result_type { std::forward<Ts>(ts)... };
  }

};

//
// delegation function which selects the correct maker
//
template<class Array, class...Ts>
auto make(Ts&&...ts)
{
  auto m = maker<Array>();
  return m(std::forward<Ts>(ts)...);
}

// vectors and arrays of non-copyable types
using vt = std::vector<std::unique_ptr<int>>;
using at = std::array<std::unique_ptr<int>,2>;


int main(){
    // build an array, using make<> for consistency
    auto a = make<at>(std::make_unique<int>(10), std::make_unique<int>(20));

    // build a vector, using make<> because an initializer_list requires a copyable type  
    auto v = make<vt>(std::make_unique<int>(10), std::make_unique<int>(20));
}

Question 6

ইতিমধ্যে উত্তর হিসাবে এটি বর্তমান মানকটিতে অনুমোদিত নয় বলে মনে হচ্ছে । প্রারম্ভিকের তালিকার পরিবর্তে ফাংশনটিকে ভ্যারিয়্যাডিক হিসাবে সংজ্ঞায়িত করে অনুরূপ কিছু অর্জনের জন্য এখানে আরও কাজ করার সুযোগ রয়েছে।

#include <vector>
#include <utility>

// begin helper functions

template <typename T>
void add_to_vector(std::vector<T>* vec) {}

template <typename T, typename... Args>
void add_to_vector(std::vector<T>* vec, T&& car, Args&&... cdr) {
  vec->push_back(std::forward<T>(car));
  add_to_vector(vec, std::forward<Args>(cdr)...);
}

template <typename T, typename... Args>
std::vector<T> make_vector(Args&&... args) {
  std::vector<T> result;
  add_to_vector(&result, std::forward<Args>(args)...);
  return result;
}

// end helper functions

struct S {
  S(int) {}
  S(S&&) {}
};

void bar(S&& s) {}

template <typename T, typename... Args>
void foo(Args&&... args) {
  std::vector<T> args_vec = make_vector<T>(std::forward<Args>(args)...);
  for (auto& arg : args_vec) {
    bar(std::move(arg));
  }
}

int main() {
  foo<S>(S(1), S(2), S(3));
  return 0;
}

ভেরিয়াদিক টেম্পলেটগুলি আরম্ভকারী_ তালিকার বিপরীতে যথাযথভাবে আর-মান উল্লেখগুলি পরিচালনা করতে পারে।

এই উদাহরণ কোডে, আমি আসল কোডের অনুরূপ তৈরি করতে ভেরিয়েডিক আর্গুমেন্টগুলিকে ভেক্টরে রূপান্তরিত করতে ছোট সহায়ক সহায়ক ফাংশনগুলির একটি সেট ব্যবহার করেছি। তবে অবশ্যই আপনি পরিবর্তে পরিবর্তে ভেরিয়াদিক টেম্পলেটগুলির সাথে একটি পুনরাবৃত্ত ফাংশন লিখতে পারেন।

Question 7

আমার কাছে অনেকগুলি সহজ বাস্তবায়ন রয়েছে যা একটি মোড়কের ক্লাস ব্যবহার করে যা উপাদানগুলিকে সরানোর অভিপ্রায় চিহ্নিত করতে ট্যাগ হিসাবে কাজ করে। এটি একটি সংকলন-সময় ব্যয়।

মোড়কের ক্লাসটি ব্যবহার করার জন্য ডিজাইন করা হয়েছে যেভাবে std::moveব্যবহৃত হয়, কেবল এটির std::moveসাথে প্রতিস্থাপন করুন move_wrapperতবে এর জন্য সি ++ 17 প্রয়োজন requires পুরানো চশমা জন্য, আপনি একটি অতিরিক্ত নির্মাতা পদ্ধতি ব্যবহার করতে পারেন।

আপনাকে বিল্ডার পদ্ধতি / নির্মাতারা লিখতে হবে যা অভ্যন্তরের মোড়কের ক্লাস গ্রহণ করে এবং ততক্ষণে initializer_listউপাদানগুলিকে সরিয়ে দেয়।

আপনার যদি সরানোর পরিবর্তে কিছু উপাদান অনুলিপি করার প্রয়োজন হয় তবে তা অনুলিপি করার আগে একটি অনুলিপি তৈরি করুন initializer_list।

কোডটি স্ব-ডকুমেন্টেড হওয়া উচিত।

#include <iostream>
#include <vector>
#include <initializer_list>

using namespace std;

template <typename T>
struct move_wrapper {
    T && t;

    move_wrapper(T && t) : t(move(t)) { // since it's just a wrapper for rvalues
    }

    explicit move_wrapper(T & t) : t(move(t)) { // acts as std::move
    }
};

struct Foo {
    int x;

    Foo(int x) : x(x) {
        cout << "Foo(" << x << ")\n";
    }

    Foo(Foo const & other) : x(other.x) {
        cout << "copy Foo(" << x << ")\n";
    }

    Foo(Foo && other) : x(other.x) {
        cout << "move Foo(" << x << ")\n";
    }
};

template <typename T>
struct Vec {
    vector<T> v;

    Vec(initializer_list<T> il) : v(il) {
    }

    Vec(initializer_list<move_wrapper<T>> il) {
        v.reserve(il.size());
        for (move_wrapper<T> const & w : il) {
            v.emplace_back(move(w.t));
        }
    }
};

int main() {
    Foo x{1}; // Foo(1)
    Foo y{2}; // Foo(2)

    Vec<Foo> v{Foo{3}, move_wrapper(x), Foo{y}}; // I want y to be copied
    // Foo(3)
    // copy Foo(2)
    // move Foo(3)
    // move Foo(1)
    // move Foo(2)
}

Question 8

একটি ব্যবহার করার পরিবর্তে std::initializer_list<T>, আপনি আপনার যুক্তিটিকে অ্যারের মূল মূল্য উল্লেখ হিসাবে ঘোষণা করতে পারেন:

template <typename T>
void bar(T &&value);

template <typename T, size_t N>
void foo(T (&&list)[N] ) {
   std::for_each(std::make_move_iterator(std::begin(list)),
                 std::make_move_iterator(std::end(list)),
                 &bar);
}

void baz() {
   foo({std::make_unique<int>(0), std::make_unique<int>(1)});
}

উদাহরণটি দেখুন std::unique_ptr<int>: https://gcc.godbolt.org/z/2uNxv6

Question 9

সিপিটিউথগুলিতেin<T> বর্ণিত আইডিয়ামটি বিবেচনা করুন । ধারণাটি রান-টাইমে লভ্যালু / মূল্য নির্ধারণ করা এবং তারপরে কল মুভ বা অনুলিপি-নির্ধারণ করা। প্রারম্ভিক_লিস্টের সরবরাহকৃত স্ট্যান্ডার্ড ইন্টারফেসটি কনস্ট রেফারেন্স হলেও মান / লভ্যালু সনাক্ত করবে।in<T>