Swd को std द्वारा क्यों बुलाया जाता है :: केवल अगर मेरे कंटेनर में 32 से अधिक तत्व हैं?

Question

नमस्ते, मेरा एक आसान सवाल है:

class A 
{
public:
    A(int);
    A(const A&);
    A& operator=(const A&);
    ~A();
private:
    int* ptr_;

    friend bool operator<(const A&, const A&);
    friend void swap(A&, A&);
};

A::A(int x) : 
    ptr_(new int(x))
{}

A::A(const A& rhs) :
    ptr_(rhs.ptr_ ? new int(*rhs.ptr_) : nullptr)
{}

A& A::operator = (const A & rhs)
{
    int* tmp = rhs.ptr_ ? new int(*rhs.ptr_) : nullptr;
    delete ptr_;
    ptr_ = tmp;

    return *this;
}

A::~A()
{
    delete ptr_;
}

bool operator<(const A& lhs, const A& rhs)
{
    cout << "operator<(const A&, const A&)" << endl;
    return *lhs.ptr_ < *rhs.ptr_;
}

void swap(A& lhs, A& rhs)
{
    cout << "swap(A&, A&)" << endl;
    using std::swap;
    swap(lhs.ptr_, rhs.ptr_);
}

int main()
{

    std::vector<A> v{ 33,32,31,30,29,28,27,26,25,24,23,22, 21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5, 4,3,2,1 };
    std::sort(v.begin(), v.end());

}

32 से अधिक तत्वों के साथ, सॉर्ट कॉल करता है swap । 32 तत्वों या उससे कम के साथ, तत्वों को अभी भी सॉर्ट किया swapजाता है लेकिन कहा नहीं जाता है।

• मैं x 64 पर MSVC ++ 2019 का उपयोग कर रहा हूं।
• कब है swap कहा जाता है और कब नहीं और क्यों होता है? धन्यवाद!
• मैंने swapकॉपी-असाइनमेंट का उपयोग केवल कॉपी-असाइनमेंट ऑपरेटर से सॉर्ट से अलग करने के लिए नहीं किया।

Comments

std::sortयदि तत्वों की संख्या 32 या उससे कम है, तो सम्मिलन सॉर्ट पर रीसेट करता है और अन्यथा त्वरित सॉर्ट का उपयोग करता है।

— Evg

@ ईवीजी क्या इस विशेष संदर्भ के लिए एक आवश्यकता है या एक स्पष्टीकरण है?

— फ्राँस्वा एंड्रीक्स

@ फ़्राँस्वाएंड्रीक्स, यह Microsoft मानक पुस्तकालय का कार्यान्वयन विवरण है। मेरा अनुमान है कि यह ओपी द्वारा देखे गए व्यवहार का कारण है। मैं वर्तमान में अधिक जानकारी हासिल करने के लिए स्रोत कोड देख रहा हूं।

— Evg

स्रोत का प्रासंगिक हिस्सा है: while (_ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal)जहां _ISORT_MAX32 का मान दिया गया है। <algorithm>वी.एस. 16.5.0 का उपयोग करने वाली लाइन 3447

— क्रिसमम

किसी भी भाषा में किसी भी आधुनिक मानक पुस्तकालयों में किसी भी वास्तविक क्विकॉर्ट का उपयोग नहीं किया जाता है। सभी मिश्रित मिश्रित संस्करणों का उपयोग करते हैं जो केवल एक क्विकॉर्ट है जब तत्वों की संख्या काफी बड़ी होती है। उदाहरण के लिए, जावा और पायथन Timsort का उपयोग करते हैं जबकि .NET फ्रेमवर्क और GCC का C ++ पुस्तकालय इंट्रोसोर्ट का उपयोग करते हैं । libstdc ++ और libc ++ भी लघु अनुक्रमों के लिए सम्मिलन प्रकार का उपयोग करते हैं। देखें कि C ++ 11 std :: विभिन्न STL कार्यान्वयन में किस एल्गोरिदम का उपयोग किया जाता है?

— फुलकव

Answer 1

Microsoft std::sortकार्यान्वयन इस तरह दिखता है:

const int ISORT_MAX = 32;  // maximum size for insertion sort

template<class RanIt, class Diff, class Pr>
void Sort(RanIt First, RanIt Last, Diff Ideal, Pr Pred)
{
    Diff Count;
    for (; ISORT_MAX < (Count = Last - First) && 0 < Ideal; )
    {   // divide and conquer by quicksort
        pair<RanIt, RanIt> Mid = Unguarded_partition(First, Last, Pred);

        // ...
    }

    if (ISORT_MAX < Count)
    {   // heap sort if too many divisions
        Make_heap(First, Last, Pred);
        Sort_heap(First, Last, Pred);
    }
    else if (1 < Count)
        Insertion_sort(First, Last, Pred);  // small
}

जब सॉर्ट की जाने वाली सीमा में 32 तत्व या उससे कम होते हैं, तो Sortप्रविष्टि सॉर्ट का उपयोग करता है। सम्मिलन प्रकार swapइसके कार्यान्वयन में उपयोग नहीं करता है । अन्यथा, डिवाइड-एंड-कॉनक्रे क्विक सॉर्ट का उपयोग किया जाता है। में कार्यान्वयन यह कहता है iter_swap(अंदर Unguarded_partition), जो बारी कॉल में swap:

template<class FwdIt1, class FwdIt2>
void iter_swap(FwdIt1 Left, FwdIt2 Right)
{   // swap *Left and *Right
    swap(*Left, *Right);
}

ये सभी कार्यान्वयन विवरण हैं। वे एक मानक पुस्तकालय कार्यान्वयन से दूसरे में भिन्न होते हैं।

Comments

libcxx प्रकार के आधार पर 6 या 30 से छोटे लंबाई के अनुक्रम के लिए सम्मिलन प्रकार का उपयोग करता है। libstd ++ 16 तत्वों या उससे कम के दृश्यों के लिए करता है। C ++ 11 std :: सॉर्ट विभिन्न एसटीएल कार्यान्वयन में किस एल्गोरिदम का उपयोग किया जाता है?

— फुलकव