पहले स्वैपिंग फ़ंक्शन के साथ क्या गलत है?

मैं एक सरणी के तत्वों के क्रमपरिवर्तन उत्पन्न करने के लिए एक कोड लिख रहा हूँ। मैंने दो अलग-अलग प्रकार के स्वैपिंग फ़ंक्शंस लिखे हैं जो अस्थायी स्टोरेज का उपयोग करते हैं, जबकि कोई अन्य अस्थायी स्टोरेज का उपयोग नहीं करता है, आउटपुट उत्पन्न नहीं कर रहा है। यह क्यों हो रहा है ??

निम्नलिखित कोड ठीक काम करता है

#include
#include
using namespace std;
int tt=0;
void swap1 (int v[], int i, int j) {
    int t;

    t = v[i];
    v[i] = v[j];
    v[j] = t;
}   
void permute(int arr[],int n,int index)
{
     if(index==n)
                {
                for(int i=0;i< n ;j++)
         {
           swap1(arr,index,j);
           permute(arr,n,index+1); 
           swap1(arr,j,index);           
         }        
}
int main()
{
    int arr[]={'a','b','c','d'};
    permute(arr,4,0);
    cout<

जबकि निम्न कोड क्रमपरिवर्तन आउटपुट नहीं करता है:

#include
#include
using namespace std;
int tt=0;
void swap(int v[],int i,int j)
{
     v[i]= v[i] + v[j];
     v[j]= v[i] - v[j];
     v[i]= v[i] - v[j];
}
void permute(int arr[],int n,int index)
{
     if(index==n)
                {
                for(int i=0;i< n ;j++)
         {
           swap(arr,index,j);
           permute(arr,n,index+1); 
           swap(arr,j,index);           
         }        
}
int main()
{
    int arr[]={'a','b','c','d'};
    permute(arr,4,0);
    cout<
0
जोड़ा संपादित
विचारों: 1
यह भी याद रखें कि std :: swap() मौजूद है और जब संभव हो तो इसका उपयोग किया जाना चाहिए, लेकिन आपका स्वैप() फ़ंक्शन में नाम-संघर्ष हो सकता है क्योंकि आप का उपयोग कर उपयोग करते हैं नेमस्पेस std;
जोड़ा लेखक stefaanv, स्रोत

2 उत्तर

कृपया, जो भी देवताओं में आप विश्वास करते हैं (या अन्यथा) के प्यार के लिए, अपने दूसरे स्वैप फ़ंक्शन (या डरावनी एक्सओआर-स्वैप चाल) जैसी बदसूरत हैक का उपयोग न करें।

वे एक अस्थायी अस्थायी-परिवर्तनीय समाधान की तुलना में पूरी तरह अनावश्यक और आमतौर पर धीमे हैं। इसके परिणामस्वरूप आपका कोड द डेली डब्ल्यूटीएफ , और प्रोग्रामर की पीढ़ियों (जिनके पास है) जैसी साइटों पर उपस्थिति होगी इस तरह के क्रूर को बनाए रखने के लिए) सदियों से आगे अपना नाम शाप देंगे :-)

और, किसी भी मामले में, यदि वे दो तत्व "स्वैपिंग" कर रहे हैं, तो वे काम नहीं करेंगे क्योंकि आप तुरंत करते हैं:

v[i]= v[i] + v[j];

जहां i और j एक ही मान हैं, आपने काम करने के लिए अन्य चरणों के लिए आवश्यक जानकारी खो दी है।

आप इसे क्रिया में निम्नानुसार देख सकते हैं। मान लें कि आपके पास दो विशिष्ट चर, a = 20 और b = 30 हैं। अपने चरणों के माध्यम से काम करें:

a = a + b; //a <- (20 + 30) = 50, b still = 30.
b = a - b; //b <- (50 - 30) = 20, a still = 50.
a = a - b; //a <- (50 - 20) = 30, b still = 20.

और वे स्वैप हो गए हैं, यद्यपि आप शायद ओवरफ्लो और एन्कोडिंग योजनाओं के किनारे के मामलों में देखना चाहते हैं जो कि दो पूरक नहीं हैं (किसी भी तरह से, सुनिश्चित नहीं है कि सी ++ लोगों के पूरक या साइन-आयाम की अनुमति देता है)।

लेकिन देखते हैं कि क्या होता है जब a और b दोनों समान चर होते हैं (समान मान नहीं बल्कि वास्तविक एक ही चर, एक संदर्भ की तरह)। तो वे "दोनों" का मूल्य 20 है और आप उम्मीद करेंगे कि वे अभी भी स्वैप के बाद 20 हो जाएं लेकिन चलो एक नज़र डालें:

a = a + b; //a <- (20 + 20) = 40, AND b = 40 as well.
b = a - b; //b <- (40 - 40) =  0, AND a =  0 as well.
a = a - b; //a <- ( 0 -  0) =  0, AND b =  0 as well.

यह वास्तव में आपके द्वारा अपेक्षित परिणाम नहीं है।

0
जोड़ा
सुझाव के लिए @paxdiablo धन्यवाद ....
जोड़ा लेखक manyu, स्रोत
+1 को बदसूरत हैक का उपयोग करने से रोकने के लिए +1 जो कि कोई लाभ नहीं है क्योंकि हम 8-बिट माइक्रोप्रोसेसरों पर असेंबली भाषा का उपयोग करने से दूर चले गए ...
जोड़ा लेखक Axel, स्रोत
इसके अलावा, सरणी की सामग्री के आधार पर, गणना के दौरान एक अतिप्रवाह/अंडरफ्लो हो सकता है।
जोड़ा लेखक swegi, स्रोत
void swap(int v[],int i,int j)
{
     v[i]= v[i] + v[j];
     v[j]= v[i] - v[j];
     v[i]= v[i] - v[j];
}

काम नहीं करता है जब i == j (फिर यह v [i] से 0 सेट करता है), जो आपके लूप के साथ होता है

for (int j = index; j < n; ++j) {
    swap(arr, index, j);
0
जोड़ा
बस मेरे दिमाग पर क्लिक नहीं किया .... बहुत बहुत धन्यवाद, आपने मुझे बहुत समय बचाया। :)
जोड़ा लेखक manyu, स्रोत