কীভাবে বৈকল্পিক টেম্পলেট আর্গুমেন্ট সংরক্ষণ করবেন?

Question 1

পরে ব্যবহারের জন্য কোনও প্যারামিটার প্যাক সংরক্ষণ করা কি সম্ভব?

template <typename... T>
class Action {
private:        
    std::function<void(T...)> f;
    T... args;  // <--- something like this
public:
    Action(std::function<void(T...)> f, T... args) : f(f), args(args) {}
    void act(){
        f(args);  // <--- such that this will be possible
    }
}

তারপরে পরে:

void main(){
    Action<int,int> add([](int x, int y){std::cout << (x+y);}, 3, 4);

    //...

    add.act();
}

Question 2

আপনি এখানে যা করতে চান তা সম্পাদন করতে আপনাকে আপনার টেমপ্লেট যুক্তিগুলি একটি টিপলে সংরক্ষণ করতে হবে:

std::tuple<Ts...> args;

তদ্ব্যতীত, আপনাকে আপনার নির্মাতাকে কিছুটা পরিবর্তন করতে হবে। বিশেষত, argsএকটি দিয়ে আরম্ভ করা std::make_tupleএবং আপনার প্যারামিটার তালিকায় সর্বজনীন রেফারেন্সের অনুমতি দেওয়া:

template <typename F, typename... Args>
Action(F&& func, Args&&... args)
    : f(std::forward<F>(func)),
      args(std::forward<Args>(args)...)
{}

তদুপরি, আপনাকে অনেকটা এর মতো সিকোয়েন্স জেনারেটর স্থাপন করতে হবে:

namespace helper
{
    template <int... Is>
    struct index {};

    template <int N, int... Is>
    struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};

    template <int... Is>
    struct gen_seq<0, Is...> : index<Is...> {};
}

এবং এই জাতীয় জেনারেটর গ্রহণের ক্ষেত্রে আপনি নিজের পদ্ধতিটি প্রয়োগ করতে পারেন:

template <typename... Args, int... Is>
void func(std::tuple<Args...>& tup, helper::index<Is...>)
{
    f(std::get<Is>(tup)...);
}

template <typename... Args>
void func(std::tuple<Args...>& tup)
{
    func(tup, helper::gen_seq<sizeof...(Args)>{});
}

void act()
{
   func(args);
}

এবং এটি! সুতরাং এখন আপনার ক্লাসটি দেখতে এইরকম হওয়া উচিত:

template <typename... Ts>
class Action
{
private:
    std::function<void (Ts...)> f;
    std::tuple<Ts...> args;
public:
    template <typename F, typename... Args>
    Action(F&& func, Args&&... args)
        : f(std::forward<F>(func)),
          args(std::forward<Args>(args)...)
    {}

    template <typename... Args, int... Is>
    void func(std::tuple<Args...>& tup, helper::index<Is...>)
    {
        f(std::get<Is>(tup)...);
    }

    template <typename... Args>
    void func(std::tuple<Args...>& tup)
    {
        func(tup, helper::gen_seq<sizeof...(Args)>{});
    }

    void act()
    {
        func(args);
    }
};

কলিরুতে আপনার সম্পূর্ণ প্রোগ্রাম এখানে।

আপডেট: এখানে একটি সহায়ক পদ্ধতি যা দ্বারা টেমপ্লেট আর্গুমেন্টগুলির বিশদকরণের প্রয়োজন হয় না:

template <typename F, typename... Args>
Action<Args...> make_action(F&& f, Args&&... args)
{
    return Action<Args...>(std::forward<F>(f), std::forward<Args>(args)...);
}

int main()
{
    auto add = make_action([] (int a, int b) { std::cout << a + b; }, 2, 3);

    add.act();
}

এবং আবার, এখানে অন্য ডেমো।

Question 3

আপনি std::bind(f,args...)এই জন্য ব্যবহার করতে পারেন । এটি একটি অস্থাবর এবং সম্ভবত অনুলিপিযোগ্য বস্তু তৈরি করবে যা ফাংশন অবজেক্টের একটি অনুলিপি এবং পরবর্তী ব্যবহারের জন্য প্রতিটি আর্গুমেন্ট সংরক্ষণ করে:

#include <iostream>
#include <utility>
#include <functional>

template <typename... T>
class Action {
public:

  using bind_type = decltype(std::bind(std::declval<std::function<void(T...)>>(),std::declval<T>()...));

  template <typename... ConstrT>
  Action(std::function<void(T...)> f, ConstrT&&... args)
    : bind_(f,std::forward<ConstrT>(args)...)
  { }

  void act()
  { bind_(); }

private:
  bind_type bind_;
};

int main()
{
  Action<int,int> add([](int x, int y)
                      { std::cout << (x+y) << std::endl; },
                      3, 4);

  add.act();
  return 0;
}

লক্ষ্য করুন যে std::bindএটি একটি ফাংশন এবং আপনার এটি ডেটার সদস্য হিসাবে কল করার ফলাফল সংরক্ষণ করতে হবে। ফলাফলের ডেটা ধরণের পূর্বাভাস দেওয়া সহজ নয় (স্ট্যান্ডার্ড এমনকি এটি সুনির্দিষ্টভাবে নির্দিষ্ট করে না), তাই আমি সংকলনের সময় সেই ডেটা টাইপের সংমিশ্রণ decltypeএবং std::declvalগণনা করতে ব্যবহার করি। Action::bind_typeউপরের সংজ্ঞা দেখুন ।

এছাড়াও লক্ষ্য করুন যে আমি কীভাবে টেম্পলেটড কনস্ট্রাক্টরে সর্বজনীন রেফারেন্স ব্যবহার করেছি। এটি নিশ্চিত করে যে আপনি ক্লাস টেম্পলেট প্যারামিটারগুলির সাথে মেলে না এমন যুক্তিগুলি পাস করতে পারবেন T...(উদাহরণস্বরূপ আপনি কয়েকটিটির সাথে রুল্যু রেফারেন্স ব্যবহার করতে পারেন Tএবং আপনি তাদের bindকল হিসাবে যেমন ফরোয়ার্ড পাবেন ))

চূড়ান্ত দ্রষ্টব্য: আপনি যদি আর্গুমেন্টগুলি রেফারেন্স হিসাবে সংরক্ষণ করতে চান (যাতে আপনার পাস করা ফাংশনটি কেবল ব্যবহারের পরিবর্তে পরিবর্তিত করতে পারে) তবে আপনার std::refসেগুলি রেফারেন্স অবজেক্টে মোড়ানোর জন্য ব্যবহার করতে হবে। কেবল একটি পাস করা T &মানটির একটি অনুলিপি তৈরি করবে, কোনও রেফারেন্স নয়।

কলিরুতে অপারেশনাল কোড

Question 4

এই প্রশ্নটি সি ++ 11 দিনের ছিল। তবে এখন অনুসন্ধান ফলাফলগুলিতে এটি সন্ধানকারীদের জন্য কিছু আপডেট:

একজন std::tupleসদস্য এখনও আর্গুমেন্ট সাধারণত সঞ্চয় করতে সহজবোধ্য উপায়। ( @ জোগোজাপানেরstd::bind অনুরূপ সমাধান এছাড়াও কাজ করবে যদি আপনি কেবল একটি নির্দিষ্ট ফাংশন কল করতে চান তবে আপনি অন্য উপায়ে যুক্তি অ্যাক্সেস করতে চান না, বা একাধিক কার্যের পক্ষে যুক্তিগুলি পাস করতে চান ইত্যাদি না)

সি ++ ১৪ এবং তারপরে , std::make_index_sequence<N>বা std::index_sequence_for<Pack...>0x499602D2 এর সমাধানেhelper::gen_seq<N> দেখা সরঞ্জামটি প্রতিস্থাপন করতে পারে :

#include <utility>

template <typename... Ts>
class Action
{
    // ...
    template <typename... Args, std::size_t... Is>
    void func(std::tuple<Args...>& tup, std::index_sequence<Is...>)
    {
        f(std::get<Is>(tup)...);
    }

    template <typename... Args>
    void func(std::tuple<Args...>& tup)
    {
        func(tup, std::index_sequence_for<Args...>{});
    }
    // ...
};

সি ++ 17 এবং std::applyতারপরে, টিপলটি আনপ্যাকিংয়ের যত্ন নিতে ব্যবহার করা যেতে পারে:

template <typename... Ts>
class Action
{
    // ...
    void act() {
        std::apply(f, args);
    }
};

সরলিকৃত বাস্তবায়ন দেখানোর জন্য এখানে একটি সম্পূর্ণ সি ++ 17 প্রোগ্রাম রয়েছে । আমি make_actionরেফারেন্সের ধরনগুলি এড়াতে আপডেটও করেছি tuple, যা সর্বদা রুল্যু যুক্তিগুলির পক্ষে খারাপ ছিল এবং লভালু যুক্তিগুলির পক্ষে মোটামুটি ঝুঁকিপূর্ণ।

Question 5

আমার মনে হয় আপনার একটি এক্সওয়াই সমস্যা আছে। আপনি যখন কলসাইটে কেবল একটি ল্যাম্বডা ব্যবহার করতে পারলেন তখন কেন প্যারামিটার প্যাকটি সঞ্চয় করতে সমস্ত সমস্যায় যাবেন? অর্থাত্,

#include <functional>
#include <iostream>

typedef std::function<void()> Action;

void callback(int n, const char* s) {
    std::cout << s << ": " << n << '\n';
}

int main() {
    Action a{[]{callback(13, "foo");}};
    a();
}