एक int वापस या एक int सूचक प्राप्त करें - क्या बेहतर है?

Question

इनमें से कौन सा बेहतर है?

void SetBit(int *flag, int bit) 
{ 
    *flag |= 1 << bit; 
} 

या

int SetBit(int flag, int bit) 
{ 
    flag |= 1 << bit; 
    return flag; 
} 

Answer 1

मैं एक दूसरे की तरह है, क्योंकि यह कोई साइड इफेक्ट भी नहीं है। न तो

flag = SetBit(flag, 4); 

Answer 2

: आप flag संशोधित करना चाहते हैं, तो आप बस परिणाम खुद के लिए प्रदान कर सकते हैं।

int SetBit(int flag, int bit) 
{ 
    return flag | 1 << bit; 
} 

Answer 3

मैं दूसरा एक बेहतर ...

चाहते हालांकि, मैं अपने फ़ंक्शन का नाम बदलने की सलाह देते हैं (यह मानते हुए वास्तविक नाम है) और वर्णनात्मक किया जाना है। "SetBit" यह वर्णन करने के लिए बहुत कुछ नहीं करता है कि फ़ंक्शन क्या करता है या देता है :)

Answer 4

यह निर्भर करता है।

पहला एक अनिवार्य शैली है, दूसरा एक कार्यात्मक शैली है।

आपको बस इतना करना

SetBit(SetBit(... SetBit(flag, b1), b2),...), bn) 

दूसरा कोई एक कार्य करें चाहते हैं। यदि आप

SetBit(&flag, b1) 
SetBit(&flag, b2) 
... 
SetBit(&flag, bn) 

पहले व्यक्ति को करना चाहते हैं। सी में, मैं बाद वाले को पसंद करूंगा (यानी अनिवार्य)। अन्य भाषाओं/संदर्भों में, पूर्व एक अच्छा विचार हो सकता है।

Answer 5

यह निर्भर करता है।

उस स्थिति में, वास्तव में कोई भी तरीका वास्तव में काम करेगा। लेकिन मैं दो विशेष मामलों के बारे में सोच सकता हूं जहां मैं एक सूचक का उपयोग करने का पक्ष लेगा।

1. यदि आप जिस प्रकार में गुजर रहे हैं वह बड़ा है और मूल्य प्रति महंगा होगा, प्रदर्शन कारणों के लिए एक सूचक का उपयोग करें।

2. यदि आपको कुछ और वापस करने की आवश्यकता है, तो शायद एक स्टेटस कोड या सफलता/विफलता संकेत, तो आपको सूचक का उपयोग करने की आवश्यकता है ताकि आप लौटने के लिए आवश्यक मूल्य वापस करने के लिए कमरे छोड़ सकें।

मैं व्यक्तिगत रूप से सोचता हूं कि उन स्थितियों के बाहर, दूसरा (मूल्य द्वारा पास/वापसी) स्पष्ट और थोड़ा अधिक पठनीय है।

Answer 6

दूसरा बेहतर है क्योंकि यह क्रैश नहीं होगा।

पहले एक अगर आप एक शून्य अमान्य सूचक में पारित दुर्घटना सकता है जाएगा, ताकि आप की जाँच करें और है कि संभाल करने के लिए कुछ कोड होना चाहिए था।

Answer 7

पॉइंटर को समय-समय पर सहेजने के लिए int पास करें।

Answer 8

मैं एक मैक्रो का प्रयोग करेंगे:

#define BIT_SET(a, bit) ((a) | (1 << (bit))) 

Answer 9

ईमानदारी से कहूं तो मैं यह सिर्फ झंडे के रूप में "जादू संख्या" का उपयोग करने के लिए प्रोत्साहित करती है लगता है:

SetBit(&flags, 12); // 12 is the flag for Super mode 

क्या आप वास्तव में चाहते हैं स्थिरांक का नाम है :

#define SUPERMODE_FLAG 12 
... 
SetBit(&flags, SUPERMODE_FLAG); 

लेकिन तुम नामित स्थिरांक उपयोग करने के लिए जा रहे हैं, तो आप के रूप में अच्छी बल्कि बिट नु से मास्क नाम दे सकते हैं सदस्यों, जिस स्थिति में आपरेशन एक सहायक समारोह के लिए कोई आवश्यकता नहीं है बहुत आसान है: जानते हुए भी उनका अर्थ के बिना,

#define SUPERMODE_MASK (1 << 12) 
.... 
flags |= SUPERMODE_MASK; 

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

Answer 10

यदि कार्य को रेखांकित किया जा रहा है तो सबसे पहले ठीक है। इनलाइनों के चारों ओर पॉइंटर्स को पास करने के लिए थोड़ा अधिक ओवरहेड डालने के बिना। (64 बिट एलपी 64 आर्क पर, int 4 बाइट्स है, पॉइंटर 8 है)

दूसरा ... फ़ंक्शन नाम सेटबिट() कुछ मामूली भ्रम पैदा करने जा रहा है। नाम का तात्पर्य है कि फ़ंक्शन कुछ बदलता है जबकि वास्तव में यह नहीं करता है। जब तक आप नाम के साथ ठीक हो, तब तक यह प्रदर्शन-वार एक बेहतर विकल्प है।

उदा। लिनक्स कर्नेल पॉइंटर संस्करण जैसी कई समान चीजों के लिए उपयोग करता है, क्योंकि अक्सर डेटाम की स्मृति स्थान पोर्टेबिलिटी के लिए महत्वपूर्ण या आवश्यक है। लेकिन वे या तो ऐसे सभी कार्यों को प्रीप्रोसेसर मैक्रो बनाते हैं या जीसीसी की हमेशा_इनलाइन विशेषता के साथ चिह्नित करते हैं। उपयोगकर्ता-भूमि, सादा अनुप्रयोग प्रोग्रामिंग के लिए, मैं कहूंगा कि दूसरे को प्राथमिकता दी जानी चाहिए। केवल एक बेहतर नाम चुनें।

Answer 11

यदि फ़ंक्शन का उपयोग करने का एकमात्र पैटर्न "variable = doSomething (variable) होगा;" और प्रदर्शन कोई मुद्दा नहीं है, मैं "डूसमिंग (& परिवर्तनीय) पर विचार करता हूं;" अधिक सुगम होने के लिए। एकमात्र बार जब मैं पूर्व का पक्ष लेता हूं तो यह होगा कि गंतव्य कभी-कभी स्रोत के अलावा कुछ और था, या यदि प्रदर्शन महत्वपूर्ण था और किसी का कंपाइलर बाद वाले मामले (एम्बेडेड सिस्टम पर आम) को कुशलतापूर्वक संभाल नहीं सकता था।

यह ध्यान दिया जाना चाहिए कि बाद वाला प्रारूप पूर्व की अनुमति देता है। वीबी शैली में:

 
Sub OrBits(ByRef N as Integer, ByVal Bits as Integer) 
    Dim OldValue as Integer 
    Do 
    OldValue = N 
    Loop While Threading.Interlocked.CompareExchange(N, OldValue or Bits, OldValue) <> OldValue 
End Sub 

इस कोड का प्रभाव हमेशा एन में या निर्दिष्ट बिट्स के लिए किया जाएगा, कुछ बदल जाता है एन जबकि समारोह चल रहा है, भले ही। रीड-एंड-रिटर्न रणनीति के साथ इस तरह के व्यवहार को हासिल करना संभव नहीं है।