कैसे सी सरणी आरंभीकरण का अनुकरण करने के लिए "int arr [] = {e1, e2, e3,…}" व्यवहार के साथ st :: :: सरणी?

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

और सभी प्रकार के शांत C ++ 11 सामान को नियोजित करता है:

• वेरिएडिक टेम्पलेट
• sizeof...
• संदर्भों को देखें
• एकदम सही अग्रेषण
• std::array, बेशक
• यूनिफॉर्म इनिशियलाइज़ेशन
• यूनिफॉर्म इनिशियलाइज़ेशन के साथ रिटर्न प्रकार को छोड़ना
• प्रकार का अनुमान ( auto)

और एक उदाहरण यहां पाया जा सकता है ।

हालाँकि , @ जोहान्स ने @ Xaade के उत्तर पर टिप्पणी में कहा है, आप ऐसे फ़ंक्शन के साथ नेस्टेड प्रकारों को प्रारंभ नहीं कर सकते। उदाहरण:

struct A{ int a; int b; };

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

इसके अलावा, आरंभिकों की संख्या कार्यान्वयन द्वारा समर्थित फ़ंक्शन और टेम्पलेट तर्कों की संख्या तक सीमित है।

Comments

वारीडिक विधि। यह इनिशियलाइज़ेशन नहीं है, असाइनमेंट की तरह अधिक है, लेकिन यह मेरे सबसे करीब आ सकता है। आरंभीकरण प्राप्त करने के लिए, आपको मेमोरी तक सीधे पहुंच प्राप्त करनी होगी।

— ली लौविरे

जाहिरा तौर पर C ++ 0x इनिशियलाइज़र सिंटैक्स का समर्थन करता है। बहुत बढ़िया। यह अधिक जटिल समर्थन के लिए भाषा समर्थन के साथ सी # की तरह अधिक हो रहा है। किसी को पता है अगर हम इंटरफेस के लिए औपचारिक भाषा का समर्थन मिलता है ???

— ली लौविरे

@Downvoter: कारण?

— Xeo

क्षमा याचना, TMPआपके प्रश्न का अर्थ क्या है ?

— केविनरपे

@kevinarpe TMP संभवतः टेम्पलेट मेटाप्रोग्रामिंग के लिए खड़ा है ।

— मधुमक्खी पालन

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

हालाँकि, इसके लिए एनआरवीओ करने के लिए कंपाइलर की आवश्यकता होती है, और फिर लौटाए गए मान की प्रति भी छोड़ देते हैं (जो कानूनी भी है लेकिन आवश्यक नहीं है)। व्यवहार में, मुझे उम्मीद है कि कोई भी C ++ कंपाइलर इस तरह का अनुकूलन करने में सक्षम होगा कि यह प्रत्यक्ष आरंभीकरण के समान तेज़ हो।

Comments

gcc 4.6.0 दूसरे को संकलित नहीं करता है, डबल से value_type में रूपांतरण को कम करने की शिकायत करता है, लेकिन clang ++ 2.9 दोनों के साथ ठीक है!

— घनबी

यह इस तरह के उत्तरों के साथ है कि मुझे सबसे ज्यादा समझ में आता है कि बज़्ने ने "एक नई भाषा की तरह" महसूस करने के बारे में क्या कहा :) वारीडिक टेम्प्लेट, लेट रिटर्न स्पेसियर और टाइप-ए-वन में कटौती!

— मथिउ एम।

@ मैथ्यू: अब @ डेडएमजी के कोड से रेवल्यू रेफ्स, परफेक्ट फॉरवर्डिंग और यूनिफॉर्म इनिशियलाइज़ेशन जोड़ें और आपको कई नए फीचर्स सेट करने होंगे। :>

— Xeo

@Cubbi: वास्तव में, जी ++ यहां सही है - सी ++ 0x में समग्र आरंभ में संकीर्ण रूपांतरण की अनुमति नहीं है (लेकिन सी ++ 03 में अनुमति दी गई - एक ब्रेकिंग परिवर्तन जिसकी मुझे जानकारी नहीं थी!)। मैं दूसरी make_arrayकॉल हटा दूंगा ।

— पावेल मिनेव

@ क्यूबी, हाँ, लेकिन यह एक स्पष्ट रूपांतरण है - यह मौन डाउनकास्ट और अन्य ऐसी चीजों को भी अनुमति देगा। यह अभी भी उपयोग करके किया जा सकता है 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 में मौजूद (जैसा कि एक कंस्ट्रक्शन-से- के विपरीत) अस्तित्व के लिए सरणी प्रकार पर एक चाल निर्माणकर्ता को मजबूर करता है ।

— याक्क - एडम नेवेरुमोंट

मैं प्यार करता हूँ कि कैसे C ++ के लोग उस सरल :-) को बुलाते हैं

— Ciro Santilli 冠状 people people people

Answer 3

पिछली पोस्ट के कुछ विचारों को मिलाकर, यहां एक समाधान है जो नेस्टेड कंस्ट्रक्शन के लिए भी काम करता है (GCC4.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;
}

समुच्चय वर्गों के लिए Unfortunatelly यह स्पष्ट प्रकार विनिर्देश की आवश्यकता है

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

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

वास्तव में यह make_arrayकार्यान्वयन आकार ... ऑपरेटर में सूचीबद्ध है

---

c ++ 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 gcc 7.0 के तहत ध्वज के साथ संकलित}

Comments

C ++ 17 के पास इसके लिए पहले से ही एक कटौती मार्गदर्शिका होनी चाहिए: en.cppreference.com/w/cpp/container/array/deduction_guides

— underscore_d

Answer 5

मुझे पता है कि यह प्रश्न पूछे जाने के बाद से यह काफी समय हो गया है, लेकिन मुझे लगता है कि मौजूदा उत्तरों में अभी भी कुछ कमियां हैं, इसलिए मैं अपने थोड़े संशोधित संस्करण का प्रस्ताव करना चाहूंगा। निम्नलिखित बिंदु हैं जो मुझे लगता है कि कुछ मौजूदा उत्तर गायब हैं।

---

1. RVO पर भरोसा करने की कोई जरूरत नहीं है

कुछ जवाबों का उल्लेख है कि हमें निर्माण को वापस करने के लिए आरवीओ पर भरोसा करने की आवश्यकता है array। वह सत्य नहीं है; हम यह सुनिश्चित करने के लिए कॉपी-लिस्ट-इनिशियलाइज़ेशन का उपयोग कर सकते हैं कि कभी भी अस्थायी रूप से निर्मित नहीं होंगे। इसलिए इसके बजाय:

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

हमें करना चाहिए:

return {{values}};

2. make_arrayएक constexprसमारोह बनाओ

यह हमें संकलन-समय निरंतर सरणियाँ बनाने की अनुमति देता है।

3. यह जांचने की आवश्यकता नहीं है कि सभी तर्क एक ही प्रकार के हैं

सबसे पहले, अगर वे नहीं हैं, तो कंपाइलर किसी भी तरह एक चेतावनी या त्रुटि जारी करेगा क्योंकि सूची-आरंभीकरण की अनुमति नहीं है। दूसरे, भले ही हम वास्तव में अपना 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कि ing a, bहै, और cएक ही प्रकार है, तो इस चेक विफल हो जाएगा, लेकिन यह शायद नहीं है हम उम्मीद करते हैं चाहते हैं। इसके बजाय, हमें उनके std::decay_t<T>प्रकार (जो सभी ints हैं) की तुलना करनी चाहिए ।

4. अग्रेषित तर्कों को क्षय करके सरणी मान प्रकार को कम करें

यह बिंदु 3 के समान है। समान कोड स्निपेट का उपयोग करना, लेकिन इस बार मूल्य प्रकार स्पष्ट रूप से निर्दिष्ट न करें:

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किसी भी अधिक cv- योग्य मूल्य प्रकार की वापसी नहीं कर सकते । लेकिन ज्यादातर समय, एक की तरह कुछ के बजाय array<const int, …>, हम const array<int, …>वैसे भी उपयोग करेंगे । एक व्यापार बंद है, लेकिन मुझे लगता है कि एक उचित एक है। C ++ 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 :: array का टेम्पलेट पैरामीटर है। इसलिए आपको std :: array <unsign int, 5> n = {1,2,3,4,5} जैसी कोई चीज चाहिए;

— जुआनकोपंजा

std::vector<>स्पष्ट पूर्णांक की आवश्यकता नहीं है, और मुझे यकीन नहीं है कि क्यों std::arrayहोगा।

— रिचर्ड

@ रिचर्ड, क्योंकि std :: वेक्टर में डायनामिक साइज़ होता है, और std :: ऐरे में निश्चित आकार होता है। इसे देखें: en.wikipedia.org/wiki/Array_(C%2B%2B)

— juanchopanza

@juanchopanza लेकिन {...}वाक्यविन्यास का अर्थ है संकलन-समय निरंतर सीमा, इसलिए ctor को सीमा को कम करने में सक्षम होना चाहिए।

— रिचर्ड

std::initializer_list::sizeएक constexprफ़ंक्शन नहीं है और इस तरह से इसका उपयोग नहीं किया जा सकता है। हालांकि उनके संस्करण के लिए libstdc ++ (जीसीसी के साथ कार्यान्वयन शिपिंग) से योजनाएं हैं constexpr।

— ल्यूक डैंटन

Answer 7

(समाधान @dyp द्वारा)

नोट: C ++ 14 ( std::index_sequence) की आवश्यकता है । हालांकि कोई std::index_sequenceC ++ 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 :: array elements की डिफ़ॉल्ट आरंभीकरण की अनदेखी की। वर्तमान में एक फिक्स के लिए देख रहे हैं।

— गेब्रियल गार्सिया

@dyp मैंने आपके कोड के साथ उत्तर को अपडेट किया। यदि आप अपना उत्तर लिखने का निर्णय लेते हैं, तो मुझे बताएं और मैं अपना परिचय दूंगा। धन्यवाद।

— गेब्रियल गार्सिया

नहीं यह ठीक है। लंबाई को कम करने के लिए एक अस्थायी सरणी बांधना आपका विचार है, और मैंने जांच नहीं की कि क्या मेरा कोड भी संकलन करता है। मुझे लगता है कि यह अभी भी आपका समाधान है, और कुछ शोधन के साथ जवाब;) एक तर्क दे सकता है कि हालांकि make_arrayपिल्ला के जवाब में वैरिएड के लिए कोई लाभ नहीं है , हालांकि।

— dyp

सही। इसके अलावा, टेम्पलेट इनिशियलाइज़र सूचियों से प्रकार नहीं घटा सकते हैं, जो कि प्रश्न की आवश्यकताओं में से एक है (नेस्टेड ब्रेडेड इनिशियलाइज़ेशन)।

— गेब्रियल गार्सिया

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 :: array कोई अड़चन नहीं है और यदि आपके पास Boost है, तो एक बार देख लें list_of()। यह सी टाइप सरणी आरंभीकरण जैसा नहीं है जो आप चाहते हैं। लेकिन करीब।

Comments

यह अच्छा है। और नेस्टेड संरचनाओं को असाइन करने के लिए इसका उपयोग करने के बारे में इसी तरह का सवाल यहां पाया जा सकता है। प्रयोग-असाइन-मैप-लिस्ट-ऑफ-फॉर-कॉम्प्लेक्स-प्रकारों का उपयोग करना

— असांबर

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डेटा agnostically - यह परवाह नहीं करता जो मैं इसे खाते हैं। कभी-कभी इसका मतलब है कि मेरे अग्रेषण कोड को सावधानीपूर्वक []सरणियों को std::arrayपारदर्शी रूप से चालू करना है।

Comments

"ये अच्छे समाधानों की तरह नहीं दिखते।" क्या मैं यह भी कहूंगा: पी

— कैप