সি অ্যারের সূচনাটি কীভাবে অনুকরণ করতে হবে "ইন আরআর [] = {ই 1, ই 2, ই 3,…}" স্টাড :: অ্যারের সাথে আচরণ?

Question

(দ্রষ্টব্য: এই প্রশ্নটি উপাদানগুলির সংখ্যা নির্দিষ্ট করে না দেওয়া এবং এখনও নেস্টেড ধরণগুলি সরাসরি শুরু করার অনুমতি দেওয়ার বিষয়ে ))
এই প্রশ্নটি সি অ্যারের মতো বাম ব্যবহারগুলি নিয়ে আলোচনা করে int arr[20];। উপর তার উত্তর , @James Kanze শো সি অ্যারে শেষ শক্ত ঘাঁটি এক, এটি অনন্য আরম্ভের বৈশিষ্ট্য আছে:

int arr[] = { 1, 3, 3, 7, 0, 4, 2, 0, 3, 1, 4, 1, 5, 9 };

আমাদের উপাদানগুলির সংখ্যা নির্দিষ্ট করতে হবে না, হুর! এখন বারবার সি ++ 11 ফাংশন সঙ্গে এটি উপর std::beginএবং std::endথেকে <iterator>( বা আপনার নিজের রূপের ) এবং তুমি কখনো এমনকি তার আকার মনে করতে হবে।

এখন, এর সাথে std::arrayকি অর্জনের কোনও (সম্ভবত টিএমপি) উপায় আছে ? এটিকে আরও সুন্দর দেখানোর জন্য ম্যাক্রোগুলির ব্যবহার অনুমোদিত। :)

??? std_array = { "here", "be", "elements" };

---

সম্পাদনা করুন : বিভিন্ন উত্তর থেকে সংকলিত মধ্যবর্তী সংস্করণটি এরকম দেখাচ্ছে:

#include <array>
#include <utility>

template<class T, class... Tail, class Elem = typename std::decay<T>::type>
std::array<Elem,1+sizeof...(Tail)> make_array(T&& head, Tail&&... values)
{
  return { std::forward<T>(head), std::forward<Tail>(values)... };
}

// in code
auto std_array = make_array(1,2,3,4,5);

এবং সমস্ত ধরণের শীতল সি ++ 11 স্টাফ নিয়োগ করে:

• ভারিয়াদিক টেম্পলেটগুলি
• sizeof...
• মূল্যসূত্র উল্লেখ
• নিখুঁত ফরওয়ার্ডিং
• std::array, অবশ্যই
• অভিন্ন সূচনা
• অভিন্ন সূচনা সহ ফেরতের প্রকার বাদ দেওয়া
• অনুমান টাইপ করুন ( auto)

এবং একটি উদাহরণ এখানে পাওয়া যাবে ।

যাইহোক , @ জোহানেস @ জায়েডের উত্তরের মন্তব্যে উল্লেখ করেছেন, আপনি যেমন কোনও ফাংশন দিয়ে নেস্টেড প্রকারগুলি শুরু করতে পারবেন না। উদাহরণ:

struct A{ int a; int b; };

// C syntax
A arr[] = { {1,2}, {3,4} };
// using std::array
??? std_array = { {1,2}, {3,4} };

এছাড়াও, প্রাথমিককরণের সংখ্যা বাস্তবায়ন দ্বারা সমর্থিত ফাংশন এবং টেম্পলেট আর্গুমেন্টের সংখ্যার মধ্যে সীমাবদ্ধ।

Comments

ভারিয়াদিক পদ্ধতি। এটি আরম্ভকরণ নয়, আরও কার্যভারের মতো, তবে এটি আমার কাছে আসা সবচেয়ে নিকটতম। সূচনা পেতে, আপনার স্মৃতিতে সরাসরি অ্যাক্সেস করতে হবে।

— লি লুভিয়ের

দৃশ্যত সি ++ 0x ইনিশিয়ালার সিনট্যাক্স সমর্থন করে। অসাধারণ. এটি আরও জটিল সমর্থনের জন্য ভাষা সমর্থন সহ আরও সি ​​# এর মতো হওয়ার মতো। ইন্টারফেসের জন্য আমরা যদি আনুষ্ঠানিক ভাষার সমর্থন পাই তবে যে কেউ জানেন ???

— লি লুভিয়েরে

@ডাউনভোটার: কারণ?

— জিও

দুঃখিত, TMPআপনার প্রশ্নটির অর্থ কী ?

— কেভিনার্পে 23'16

@ কেভিনার্প টিএমপি সম্ভবত টেমপ্লেট মেটাগ্রোগ্রামিংয়ের জন্য দাঁড়িয়েছে ।

— BeeOnRope

Answer 1

আমি ভাবতে পারি সেরা:

template<class T, class... Tail>
auto make_array(T head, Tail... tail) -> std::array<T, 1 + sizeof...(Tail)>
{
     std::array<T, 1 + sizeof...(Tail)> a = { head, tail ... };
     return a;
}

auto a = make_array(1, 2, 3);

তবে এটির জন্য এনআরভিও করার জন্য সংকলকটির প্রয়োজন, এবং তারপরে ফিরে আসা মূল্যের অনুলিপিও এড়িয়ে যান (যা আইনীও তবে প্রয়োজনীয় নয়)। অনুশীলনে, আমি প্রত্যাশা করব যে কোনও সি ++ সংকলক এটি সরাসরি প্রাথমিককরণের তুলনায় দ্রুততর যেটিকে অনুকূল করতে সক্ষম হবে।

Comments

জিসিসি 4.6.0 দ্বিতীয়টি সংকলন করতে দেয় না, দ্বিগুণ থেকে মান_প্রকারভেদে রূপান্তরকরণ সম্পর্কে অভিযোগ করে, তবে ঝাঁকুনি ++ 2.9 উভয়ের সাথেই ঠিক আছে!

— কুবিবি

এটি এর মতো উত্তর সহ যা আমি বুঝতে পেরেছি যে বার্জন "নতুন ভাষার মতো" বলে অনুভূতি সম্পর্কে কী বলেছিলেন :) ভেরিয়াদিক টেম্পলেট, দেরী রিটার্ন স্পেসিফায়ার এবং টাইপ ছাড় কাটা টাইপ!

— ম্যাথিউ এম।

@ ম্যাথিউঃ: এখন @ ডেডএমজির কোড থেকে রুল্যু রেফ, নিখুঁত ফরোয়ার্ডিং এবং অভিন্ন সূচনা যোগ করুন এবং আপনার অনেকগুলি নতুন বৈশিষ্ট্য সেট রয়েছে। :>

— Xeo

@ কুবিবি: আসলে, জি ++ ঠিক এখানে - সংকীর্ণ রূপান্তরগুলি সি ++ 0 এক্স-তে সামগ্রিক সূচনাতে অনুমোদিত নয় (তবে সি ++ 03-এ অনুমোদিত a এমন একটি পরিবর্তন যা আমি অবগত ছিলাম না!)। আমি দ্বিতীয় make_arrayকলটি সরিয়ে ফেলব ।

— পাভেল মিনায়েভ

@ কুব্বি, হ্যাঁ, তবে এটি একটি স্পষ্ট রূপান্তর - এটি নিঃশব্দ অবনমন এবং এই জাতীয় অন্যান্য বিষয়কেও অনুমতি দেয় when এটি এখনও ব্যবহার করা যেতে পারে static_assertএবং কিছু টিএমপি কখন স্পষ্টভাবে রূপান্তরিত Tailহয় না তা সনাক্ত করার জন্য T, এবং তারপরে ব্যবহার করতে পারে T(tail)..., তবে এটি বাকী রয়েছে পাঠকের জন্য অনুশীলন হিসাবে :)

— পাভেল মিনায়েভ

Answer 2

আমি একটি সহজ আশা করি make_array।

template<typename ret, typename... T> std::array<ret, sizeof...(T)> make_array(T&&... refs) {
    // return std::array<ret, sizeof...(T)>{ { std::forward<T>(refs)... } };
    return { std::forward<T>(refs)... };
}

Comments

সরান std::array<ret, sizeof...(T)>উপর returnবিবৃতি। এটি নির্লজ্জভাবে T&&C ++ 14 এবং C ++ 11 -এ অ্যারে টাইপের (যেমন কনস্ট্রাক্ট-এর বিপরীতে ) উপস্থিত থাকতে বাধ্য করে ।

— ইয়াক্ক - অ্যাডাম নেভ্রামামন্ট

আমি পছন্দ করি কীভাবে সি ++ লোকেরা

— সাধারণটিকে

Answer 3

পূর্ববর্তী পোস্টগুলি থেকে কয়েকটি ধারণার সংমিশ্রণে, এখানে এমন একটি সমাধান রয়েছে যা নেস্টেড নির্মাণের জন্যও কাজ করে (জিসিসি 4.6 এ পরীক্ষিত):

template <typename T, typename ...Args>
std::array<T, sizeof...(Args) + 1> make_array(T && t, Args &&... args)
{
  static_assert(all_same<T, Args...>::value, "make_array() requires all arguments to be of the same type."); // edited in
  return std::array<T, sizeof...(Args) + 1>{ std::forward<T>(t), std::forward<Args>(args)...};
}

আশ্চর্যের বিষয় হল, রিটার্নের মানটিকে মূল্যের রেফারেন্স হিসাবে তৈরি করতে পারে না, যা নেস্টেড নির্মাণের জন্য কাজ করবে না। যাইহোক, এখানে একটি পরীক্ষা:

auto q = make_array(make_array(make_array(std::string("Cat1"), std::string("Dog1")), make_array(std::string("Mouse1"), std::string("Rat1"))),
                    make_array(make_array(std::string("Cat2"), std::string("Dog2")), make_array(std::string("Mouse2"), std::string("Rat2"))),
                    make_array(make_array(std::string("Cat3"), std::string("Dog3")), make_array(std::string("Mouse3"), std::string("Rat3"))),
                    make_array(make_array(std::string("Cat4"), std::string("Dog4")), make_array(std::string("Mouse4"), std::string("Rat4")))
                    );

std::cout << q << std::endl;
// produces: [[[Cat1, Dog1], [Mouse1, Rat1]], [[Cat2, Dog2], [Mouse2, Rat2]], [[Cat3, Dog3], [Mouse3, Rat3]], [[Cat4, Dog4], [Mouse4, Rat4]]]

(শেষ আউটপুটের জন্য আমি আমার সুন্দর-প্রিন্টার ব্যবহার করছি ))

---

আসলে, আসুন আমরা এই নির্মাণের ধরণের সুরক্ষা উন্নত করি। আমাদের অবশ্যই সব ধরণের একই হতে হবে। একটি উপায় হ'ল স্থিতিশীল যুক্তি যুক্ত করা, যা আমি উপরে সম্পাদনা করেছি। অন্য উপায়টি কেবল তখনই সক্ষম করা হয় make_arrayযখন প্রকারগুলি একই রকম হয়:

template <typename T, typename ...Args>
typename std::enable_if<all_same<T, Args...>::value, std::array<T, sizeof...(Args) + 1>>::type
make_array(T && t, Args &&... args)
{
  return std::array<T, sizeof...(Args) + 1> { std::forward<T>(t), std::forward<Args>(args)...};
}

যে কোনও উপায়ে, আপনার বৈকল্পিক all_same<Args...>ধরণের বৈশিষ্ট্যের প্রয়োজন হবে । এখানে এটা হল থেকে সরলীকরণ std::is_same<S, T>(নোট যে ক্ষীয়মান এর মিশ করার অনুমতি গুরুত্বপূর্ণ T, T&, T const &ইত্যাদি):

template <typename ...Args> struct all_same { static const bool value = false; };
template <typename S, typename T, typename ...Args> struct all_same<S, T, Args...>
{
  static const bool value = std::is_same<typename std::decay<S>::type, typename std::decay<T>::type>::value && all_same<T, Args...>::value;
};
template <typename S, typename T> struct all_same<S, T>
{
  static const bool value = std::is_same<typename std::decay<S>::type, typename std::decay<T>::type>::value;
};
template <typename T> struct all_same<T> { static const bool value = true; };

নোট করুন যে make_array()অনুলিপি-দ্বারা-অস্থায়ী, যা সংকলক (যথেষ্ট অপ্টিমাইজেশন পতাকা সহ!) একটি মূল্য হিসাবে বিবেচনা করার অনুমতি দেয় বা অন্যথায় অপ্টিমাইজ, এবং std::arrayএকটি সামগ্রিক প্রকার, তাই সংকলক সেরা সম্ভাব্য নির্মাণ পদ্ধতি চয়ন করতে বিনামূল্যে ।

পরিশেষে, নোট করুন যে আপনি make_arrayপ্রাথমিকীকরণ সেট আপ করার সময় অনুলিপি / সরানো নির্মাণ এড়াতে পারবেন না । সুতরাং std::array<Foo,2> x{Foo(1), Foo(2)};কোনও অনুলিপি / auto x = make_array(Foo(1), Foo(2));চালনা নেই, তবে যুক্তিগুলিতে যেমন পাঠানো হয়েছে তেমন দুটি অনুলিপি / চালনা রয়েছে make_array। আমি মনে করি না যে আপনি এটির উন্নতি করতে পারেন, কারণ আপনি কোনও সহায়ক হিসাবে কোনও পরিবর্তনশীল আরম্ভকারী তালিকাটি প্রেরণ করতে পারবেন না এবং প্রকার এবং আকারকে হ্রাস করতে পারেন - যদি sizeof...প্রিপ্রোসেসরের বৈকল্পিক যুক্তিগুলির জন্য কোনও ফাংশন থাকে, তবে সম্ভবত এটি করা যেতে পারে তবে তা নয় মূল ভাষার মধ্যে।

Answer 4

ট্রেলিং রিটার্ন সিনট্যাক্স ব্যবহার করে make_arrayআরও সরল করা যায়

#include <array>
#include <type_traits>
#include <utility>

template <typename... T>
auto make_array(T&&... t)
  -> std::array<std::common_type_t<T...>, sizeof...(t)>
{
  return {std::forward<T>(t)...};
}

int main()
{
  auto arr = make_array(1, 2, 3, 4, 5);
  return 0;
}

সামগ্রিক শ্রেণীর জন্য দুর্ভাগ্যজনকভাবে এর জন্য সুস্পষ্ট ধরণের স্পেসিফিকেশন প্রয়োজন

/*
struct Foo
{
  int a, b;
}; */

auto arr = make_array(Foo{1, 2}, Foo{3, 4}, Foo{5, 6});

আসলে এই make_arrayবাস্তবায়নটি আকারের ... অপারেটরে তালিকাভুক্ত

---

সি ++ 17 সংস্করণ

ধন্যবাদ বর্গ টেমপ্লেটের জন্য টেমপ্লেট যুক্তি সিদ্ধান্তগ্রহণ প্রস্তাব আমরা সিদ্ধান্তগ্রহণ নির্দেশিকা ব্যবহার করতে পারেন পরিত্রাণ পেতে make_arrayসাহায্যকারী

#include <array>

namespace std
{
template <typename... T> array(T... t)
  -> array<std::common_type_t<T...>, sizeof...(t)>;
}

int main()
{
  std::array a{1, 2, 3, 4};
  return 0; 
}

_{-std=c++1zX86-64 গিসি 7.0 এর অধীনে পতাকা সহ সংকলিত}

Comments

সি ++ 17 এর জন্য এর জন্য ইতিমধ্যে একটি ছাড়ের গাইড থাকতে হবে: en.cppreferences.com/w/cpp/container/array/eduction_guides

— আন্ডারস্কোর_ডি

Answer 5

আমি জানি যে এই প্রশ্নটি জিজ্ঞাসা করার পরে বেশ কিছুটা সময় হয়ে গেছে, তবে আমি মনে করি যে বিদ্যমান উত্তরগুলির এখনও কিছু কমতি রয়েছে, তাই আমি আমার সামান্য পরিবর্তিত সংস্করণটি প্রস্তাব করতে চাই। নীচে এমন কিছু বিষয় রয়েছে যা আমি মনে করি কিছু বিদ্যমান উত্তর অনুপস্থিত রয়েছে।

---

1. আরভিওর উপর নির্ভর করার দরকার নেই

কিছু উত্তর উল্লেখ করে যে আমাদের নির্মাণকৃতটি ফিরিয়ে দিতে আরভিওর উপর নির্ভর করতে হবে array। ওটা সত্যি না; অস্থায়ীতা তৈরি করা হবে না গ্যারান্টি জন্য আমরা অনুলিপি-তালিকা-সূচনা ব্যবহার করতে পারি । এর পরিবর্তে:

return std::array<Type, …>{values};

আমাদের করা উচিত:

return {{values}};

2. make_arrayএকটি constexprফাংশন করুন

এটি আমাদের সংকলন-সময় ধ্রুবক অ্যারে তৈরি করতে দেয়।

৩. সমস্ত আর্গুমেন্ট একই ধরণের কিনা তা খতিয়ে দেখার দরকার নেই

প্রথমত, যদি সেগুলি না থাকে, সংকলক যেভাবেই কোনও সতর্কতা বা ত্রুটি জারি করবে কারণ তালিকা-সূচনা সংকীর্ণ হওয়ার অনুমতি দেয় না। দ্বিতীয়ত, এমনকি যদি আমরা সত্যিই আমাদের নিজের static_assertকাজটি করার সিদ্ধান্ত নিয়েছি (সম্ভবত আরও ভাল ত্রুটির বার্তা সরবরাহ করার জন্য), তবুও আমাদের সম্ভবত কাঁচা প্রকারের পরিবর্তে যুক্তিগুলির ক্ষয়িষ্ণু প্রকারের তুলনা করা উচিত । উদাহরণ স্বরূপ,

volatile int a = 0;
const int& b = 1;
int&& c = 2;

auto arr = make_array<int>(a, b, c);  // Will this work?

যদি আমরা কেবল static_assertএটিকেই চিহ্নিত করি a, bএবং cএকই ধরণের থাকে, তবে এই চেকটি ব্যর্থ হবে, তবে এটি সম্ভবত আমরা প্রত্যাশা করব না। পরিবর্তে, আমাদের তাদের std::decay_t<T>ধরণের (যা সমস্ত intগুলি) তুলনা করা উচিত ।

4. ফরোয়ার্ড আর্গুমেন্ট ক্ষয় করে অ্যারের মান প্রকার হ্রাস করুন

এটি পয়েন্ট 3 এর অনুরূপ code একই কোড স্নিপেট ব্যবহার করে, তবে এবার মান প্রকারটি স্পষ্টভাবে উল্লেখ করবেন না:

volatile int a = 0;
const int& b = 1;
int&& c = 2;

auto arr = make_array(a, b, c);  // Will this work?

আমরা সম্ভবত একটি করতে চাই array<int, 3>, কিন্তু বিদ্যমান উত্তরের বাস্তবায়ন সম্ভবত এটি করতে ব্যর্থ। আমরা কি করতে পারেন, এর পরিবর্তে একটি ফিরে std::array<T, …>, একটি ফিরতি std::array<std::decay_t<T>, …>।

এই পদ্ধতির সম্পর্কে একটি অসুবিধা রয়েছে: আমরা arrayসিভি-যোগ্য মানের কোনও ধরণের আর ফিরিয়ে দিতে পারি না । তবে বেশিরভাগ সময় array<const int, …>আমরা এর মতো কিছু না করে const array<int, …>যেভাবেই ব্যবহার করব। একটি বাণিজ্য বন্ধ আছে, কিন্তু আমি একটি যুক্তিসঙ্গত মনে করি। সি ++ 17 std::make_optionalএছাড়াও এই পদ্ধতি গ্রহণ করে:

template< class T > 
constexpr std::optional<std::decay_t<T>> make_optional( T&& value );

---

উপরোক্ত বিষয়গুলি আমলে নিলে, make_arrayC ++ 14 এ সম্পূর্ণ কার্যকারিতা বাস্তবায়ন দেখে মনে হচ্ছে:

#include <array>
#include <type_traits>
#include <utility>

template<typename T, typename... Ts>
constexpr std::array<std::decay_t<T>, 1 + sizeof... (Ts)>
make_array(T&& t, Ts&&... ts)
    noexcept(noexcept(std::is_nothrow_constructible<
                std::array<std::decay_t<T>, 1 + sizeof... (Ts)>, T&&, Ts&&...
             >::value))

{
    return {{std::forward<T>(t), std::forward<Ts>(ts)...}};
}

template<typename T>
constexpr std::array<std::decay<T>_t, 0> make_array() noexcept
{
    return {};
}

ব্যবহার:

constexpr auto arr = make_array(make_array(1, 2),
                                make_array(3, 4));
static_assert(arr[1][1] == 4, "!");

Answer 6

সি ++ 11 স্ট্যান্ড পাত্রে (সর্বাধিক?) এই পদ্ধতিতে প্রাথমিকভাবে সহায়তা করবে ।

Comments

যাইহোক, আমি মনে করি ওপি অ্যারের আকার নির্দিষ্ট করতে চায় না, তবে আকারটি std :: অ্যারের একটি টেম্পলেট প্যারামিটার। সুতরাং আপনার স্ট্যান্ড :: :: অ্যারে <স্বাক্ষরবিহীন ইনট, 5> এন = {1,2,3,4,5 like এর মতো কিছু দরকার;

— juanchopanza

std::vector<>সুস্পষ্ট পূর্ণসংখ্যার দরকার নেই এবং কেন std::arrayহবে তা আমি নিশ্চিত নই ।

— রিচার্ড

@ রিচার্ড, কারণ স্টাড :: ভেক্টরটির গতিশীল আকার রয়েছে এবং স্ট্যান্ড :: অ্যারের স্থির আকার রয়েছে। এটি দেখুন:

— en.wikedia.org/wiki/Array_(C%2B%2B

@ জুয়ানচোপাঞ্জা তবে {...}সিনট্যাক্সটি কমপাইল -সময় ধ্রুবক ব্যাপ্তিকে বোঝায়, তাই কর্টারের সীমাটি হ্রাস করতে সক্ষম হওয়া উচিত।

— রিচার্ড

std::initializer_list::sizeকোনও constexprফাংশন নয় এবং এভাবে ব্যবহার করা যায় না। তবে libstdc ++ (জিসিসি সহ বাস্তবায়ন শিপিং) থেকে তাদের সংস্করণ রয়েছে এমন পরিকল্পনা রয়েছে constexpr।

— লুক ড্যান্টন

Answer 7

(@Dyp দ্বারা সমাধান)

দ্রষ্টব্য: C ++ 14 ( std::index_sequence) প্রয়োজন। যদিও কেউ std::index_sequenceসি ++ 11 এ প্রয়োগ করতে পারে ।

#include <iostream>

// ---

#include <array>
#include <utility>

template <typename T>
using c_array = T[];

template<typename T, size_t N, size_t... Indices>
constexpr auto make_array(T (&&src)[N], std::index_sequence<Indices...>) {
    return std::array<T, N>{{ std::move(src[Indices])... }};
}

template<typename T, size_t N>
constexpr auto make_array(T (&&src)[N]) {
    return make_array(std::move(src), std::make_index_sequence<N>{});
}

// ---

struct Point { int x, y; };

std::ostream& operator<< (std::ostream& os, const Point& p) {
    return os << "(" << p.x << "," << p.y << ")";
}

int main() {
    auto xs = make_array(c_array<Point>{{1,2}, {3,4}, {5,6}, {7,8}});

    for (auto&& x : xs) {
        std::cout << x << std::endl;
    }

    return 0;
}

Comments

আমি std :: অ্যারে উপাদানগুলির ডিফল্ট সূচনা উপেক্ষা করেছি। বর্তমানে একটি সংশোধন খুঁজছেন।

— গ্যাব্রিয়েল গার্সিয়া

@dyp আমি আপনার কোড সহ উত্তরটি আপডেট করেছি। যদি আপনি নিজের উত্তরটি লেখার সিদ্ধান্ত নেন তবে আমাকে জানান এবং আমি আমার নামটি নামিয়ে আনব। ধন্যবাদ.

— গ্যাব্রিয়েল গার্সিয়া

না এটা ঠিক আছে. দৈর্ঘ্যটি হ্রাস করার জন্য একটি অস্থায়ী অ্যারে বাঁধাই আপনার ধারণা এবং আমি আমার কোড এমনকি সংকলন করে কিনা তা পরীক্ষা করে দেখিনি। আমি মনে করি এটি এখনও আপনার সমাধান, এবং কিছু সংশোধন সহ উত্তর দিন;) কেউ তর্ক করতে পারে যদিও পপির make_arrayউত্তর হিসাবে বৈকল্পিকের কোনও লাভ নেই though

— ডিসি

ঠিক। তদ্ব্যতীত, টেমপ্লেটগুলি প্রারম্ভিক তালিকা থেকে প্রকারগুলি কমাতে পারে না, যা প্রশ্নের অন্যতম প্রয়োজনীয়তা (নেস্টেড ব্রেসড আরম্ভ) ization

— গ্যাব্রিয়েল গার্সিয়া

Answer 8

С ++ 17 কমপ্যাক্ট বাস্তবায়ন।

template <typename... T>
constexpr auto array_of(T&&... t) {
    return std::array{ static_cast<std::common_type_t<T...>>(t)... };
}

Answer 9

যদি std :: অ্যারে কোনও সীমাবদ্ধতা না হয় এবং আপনার যদি বুস্ট থাকে তবে একবার দেখুন list_of()। এটি হ'ল সি টাইপ অ্যারে প্রারম্ভিকরণের মতো নয় যা আপনি চান। তবে বন্ধ।

Comments

এটা ভাল গুলোর একটি. এবং নেস্টেড স্ট্রাকচার নির্ধারণের জন্য এটি ব্যবহার সম্পর্কে একটি অনুরূপ প্রশ্ন পাওয়া যাবে এখানে ব্যবহার-assign করুন মানচিত্রে-তালিকা অফ-জন্য-জটিল-ধরনের

— Assambar

Answer 10

একটি অ্যারে প্রস্তুতকারক প্রকার তৈরি করুন।

operator,রেফারেন্সের মাধ্যমে পূর্বের প্রতিটি উপাদানকে শৃঙ্খলাবদ্ধ করে একটি অভিব্যক্তি টেম্পলেট উত্পন্ন করতে ওভারলোড হয়।

একটি finishনিখরচায় ফাংশন যুক্ত করুন যা অ্যারে নির্মাতাকে নিয়ে যায় এবং রেফারেন্সের চেইন থেকে সরাসরি একটি অ্যারে তৈরি করে।

বাক্য গঠনটি দেখতে এরকম কিছু দেখতে পাওয়া উচিত:

auto arr = finish( make_array<T>->* 1,2,3,4,5 );

এটি {}ভিত্তিক নির্মাণের অনুমতি দেয় না , যেমনটি operator=করে। আপনি যদি ব্যবহার =করতে চান তবে আমরা এটি কাজ করতে পারি:

auto arr = finish( make_array<T>= {1}={2}={3}={4}={5} );

অথবা

auto arr = finish( make_array<T>[{1}][{2}[]{3}][{4}][{5}] );

এর কোনওোটাই ভাল সমাধানের মতো দেখায় না।

ভেরার্ডিক্স ব্যবহার আপনাকে আপনার সংকলক-আরোপিত সীমাতে ভারার্গসের সংখ্যা এবং কাঠামোগুলির {}জন্য ব্লক পুনরাবৃত্ত ব্যবহারের ক্ষেত্রে সীমাবদ্ধ করে দেয় ।

শেষ পর্যন্ত, সত্যিই ভাল সমাধান নেই।

আমি যা করি তা হ'ল আমি আমার কোডটি লিখি তাই এটি জ্ঞানবাদীভাবে T[]এবং std::arrayডেটা উভয়ই গ্রাস করে - আমি এটি কী খাওয়াই সে বিষয়ে কোনও চিন্তা নেই। কখনও কখনও এর অর্থ আমার ফরওয়ার্ডিং কোডটি সাবধানে []অ্যারেগুলিকে std::arrayস্বচ্ছভাবে পরিণত করতে হবে ।

Comments

"এগুলি ভাল সমাধানের মতো দেখায় না।" আমি কী বলব তা কি: পি

— ক্যাপগুলি