यह जांचने के लिए कि कोई कंटेनर स्थिर है या नहीं

Question

std::vector एक अस्थिर कंटेनर है, यानी वेक्टर का आकार बदलकर, इटरेटर अमान्य हो सकते हैं। इसके विपरीत, std::list या boost::container::stable_vector स्थिर कंटेनर हैं जो इटेटर को इसी तत्व को हटाने तक वैध रखते हैं।

क्या यह जांचने का कोई तरीका है कि कोई कंटेनर स्थिर है या नहीं? उदाहरण के लिए, यदि मेरे पास

template<template <typename A, typename B=std::allocator<A> > class T=std::list> 
class Foo 
{ 
} 

क्या केवल स्थिर कंटेनर के लिए अनुमति देना और अस्थिर लोगों को मना करना संभव है?

Answer 1

मुझे नहीं लगता कि ऐसी जानकारी प्रदान करने में कुछ भी उपलब्ध है, लेकिन आप अपनी खुद की विशेषता लिख ​​सकते हैं। हालांकि, आपको इसे इस्तेमाल करने वाले प्रत्येक स्थिर कंटेनर के लिए विशेषज्ञता हासिल करने की आवश्यकता होगी, जो शायद एक विकल्प नहीं है।

#include <boost/container/vector.hpp> 

#include <iostream> 
#include <type_traits> 
#include <list> 
#include <vector> 

template <template <typename...> class Container> 
struct is_stable 
    : std::false_type 
{}; 

template <> 
struct is_stable<std::list> 
    : std::true_type 
{}; 

template <> 
struct is_stable<boost::container::stable_vector> 
    : std::true_type 
{}; 

template<template <typename...> class Container = std::list> 
class Foo 
{ 
    static_assert(is_stable<Container>::value, "Container must be stable"); 
}; 

int main() 
{ 
    Foo<std::list> f1; // ok 
    Foo<std::vector> f2; // compiler error 
} 

मुझे नहीं लगता कि आप मैन्युअल विशेषज्ञता का उपयोग किए बिना स्वचालित रूप से एक कंटेनर स्थिर हो सकते हैं।

---

बस मस्ती के लिए, मैं क्या स्थिरता के लिए अवधारणा/स्वयंसिद्ध कैसा दिखेगा लेखन की कोशिश की (concepts और axioms भाषा के लिए एक विस्तार है कि considered for inclusion in C++11 थे जाता है):

concept StableGroup<typename C, typename Op> 
    : Container<C> 
{ 
    void operator()(Op, C, C::value_type); 

    axiom Stability(C c, Op op, C::size_type index, C::value_type val) 
    { 
     if (index <= c.size()) 
     { 
      auto it = std::advance(c.begin(), index); 
      op(c, val); 
      return it; 
     } 
     <-> 
     if (index <= c.size()) 
     { 
      op(c, val); 
      return std::advance(c.begin(), index); 
     } 
    } 
} 

सही ढंग से इस बारे में सोच आवश्यकता को कैप्चर करता है कि मूल कंटेनर पर प्रत्येक पुनरावर्तक संशोधित कंटेनर पर संबंधित पुनरावर्तक के बराबर है। यकीन नहीं है कि यह बहुत उपयोगी है, लेकिन इस तरह के सिद्धांतों के साथ आना एक दिलचस्प अभ्यास है :)!