c++ - सबस - सूर्य घूमता है या नहीं



जांच कैसे करें कि कंटेनर स्थिर है या नहीं (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
}

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

बस मज़े के लिए, मैं स्थिरता के लिए अवधारणा / स्वयंसिद्धता क्या विचार करेगी ( अवधारणाओं और स्वयंसेव्यों की भाषा का विस्तार, जिसे सी ++ 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);
        }
    }
}

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

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

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

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

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





containers