सीटीर्स और सेटर्स के पैराम्स के लिए नामकरण सम्मेलन

Question

आप में से उन लोगों के लिए जो आपको m_foo या foo_ जैसे किसी विशेष नोटेशन के साथ सदस्य चर का नाम देते हैं, तो आप अपने सीटर्स और सेटर्स के पैरामीटर का नाम कैसे देते हैं?

कुछ विकल्प मैं अब तक की कोशिश की है ...

Obj(int foo) : foo(foo) { } 
void set_foo(int foo) { this->foo = foo; } 

Obj(int _foo) : foo(_foo) { } 
void set_foo(int _foo) { foo = _foo; } 

Obj(int a_foo) : foo(a_foo) { } // a for "argument" 
void set_foo(int a_foo) { foo = a_foo; } 

Obj(int init_foo) : foo(init_foo) { } 
void set_foo(int new_foo) { foo = new_foo; } 

Answer 1

मैं हमेशा एक परम या Arg प्रत्यय के लिए जाते हैं, लेकिन केवल जब बहुविकल्पी आवश्यक है।

Obj(int fooArg) : foo(fooArg) 

Answer 2

मैं foo_ उपयोग कर रहा हूँ, यह _foo की तुलना में बेहतर है, क्योंकि यह कार्यान्वयन विशेष समारोह के नाम और खोजशब्दों के साथ संघर्ष नहीं होगा।

Answer 3

मैं पैरामीटर है कि स्थापित किया जा रहा के पहले अक्षर पालन करें, और इस के साथ स्पष्ट करने के लिए करते हैं ...

void setFoo(int f) { foo = f; } 

एक सरल सेटर के लिए, एक चर के लिए, यह बहुत अच्छी तरह से स्पष्ट है।

इसके अलावा, मैं अक्सर इस

int setFoo(const int f) { foo = f; } 

तो मैं स्ट्रिंग बातें कर सकते हैं एक साथ करते हैं।

Answer 4

मैं

Obj(int foo) : mFoo(foo) { } 
void setFoo(int foo) { mFoo = foo; } 

मेरे कार्यक्रमों में

साथ जा रहा हूँ। प्रतिलिपि निर्माणकर्ता और ऑपरेटर के लिए =, मैं इसे

Obj(Obj const& that):mFoo(that.mFoo) { } 

ऑपरेटरों के लिए कॉल करते हैं, मैं

Obj operator+(Obj const& lhs, Obj const& rhs) { ... } 

साथ जा रहा हूँ क्योंकि उन एल ईएफटी ज और रों आईडीई हैं और आर ight एच और एस इसकी राय।

Answer 5

कक्षाओं के लिए:

Obj(int foo) : _foo(foo) {}; 

structs के लिए:

obj_t(int foo_) : foo(foo_) {}; 

सेटर:

Obj.setFoo(int foo) { _foo = foo; } 

मैं ऑपरेटर कॉल के लिए lhs और rhs के उपयोग पर litb साथ हूँ।

मैं वर्ग सदस्य कार्यों के लिए camelCase का उपयोग करता हूं, और names_with_underscores संरचना फ़ील्ड और विधियों के लिए उपयोग करता हूं।

Answer 6

मैं m_ के साथ उपसर्ग सदस्य चर के माइक्रोसॉफ्ट सम्मेलन का पालन करता था, जैसे m_foo। मेरी वर्तमान कंपनी में सम्मेलन सदस्य चर के लिए एक पिछला अंडरस्कोर है: foo_।

आम तौर पर, यदि आप स्वयं से काम कर रहे हैं, तो आप जो भी सम्मेलन पसंद करते हैं उसका उपयोग करें। यदि आप एक टीम में काम कर रहे हैं, तो टीम जो भी सहमत हो, उसका उपयोग करें। कोड आधार में कुल मिलाकर स्थिरता महत्वपूर्ण है, विशेष सम्मेलन नहीं।

Answer 7

मैं किसी भी पहचानकर्ता के पहले चरित्र के रूप में अंडरस्कोर से बचने के लिए (मतलब से कभी भी उपयोग न करें) से बचें। मैं इसके ओवरकिल को जानता हूं लेकिन प्रयास के लायक हूं।

इस पढ़ें: What are the rules about using an underscore in a C++ identifier?

एक नियम नहीं हालांकि मैं अंडरस्कोर के उपयोग को सीमित और ऊंट मामले पसंद करते हैं मेरे चर पठनीय बनाने के लिए। लेकिन यह सिर्फ एक निजी वरीयता है और मुझे इसका उपयोग करने वाले कोड पढ़ने में कोई फर्क नहीं पड़ता।

इसके अतिरिक्त मैं अपने सदस्य चर के समान मानकों का नाम कभी नहीं मानता। कंपाइलर आपको उत्पन्न होने वाली त्रुटियों को पकड़ने में मदद नहीं करेगा (और यह वास्तविक काम करने के लिए कंपाइलर प्राप्त करने के बारे में है ताकि आप अभिव्यक्तित्मक कार्य कर सकें जो संकलक नहीं कर सकता)।

int X::setWork(int work) 
{ 
    this->work = work; // OK. But more Java like. 

    work = work;  // Compiler won't see that problem. 
} 

int X::setWork(int newWork) 
{ 
    work = newWork; // A bit harder to get wrong. 
} 

Answer 8

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

Answer 9

मैं हमेशा ऐसा करते हैं:

Obj(Bar& b) : b_(b_) {} 

आप गलती देख सकते हैं:

Obj(int foo) : foo(foo) {} 

मैं एक बार मैं इस से चोट लगी जब तक अजीब प्रतीकों जोड़कर के साथ खेल खेलने के लिए इस्तेमाल किया? (हां, बी_ एक निजी सदस्य संदर्भ चर है)। यह एक चेतावनी के बिना संकलित। मुझे डिबगिंग के 3 दिन का खर्च करें (मैं तब एक हरा प्रोग्रामर था)।

अब मैं हमेशा उसी नाम का उपयोग करता हूं ताकि टाइपोज (और बाद में क्रैश) से बच सकें। प्रारंभिक सूची में कोई अस्पष्टता नहीं है। भाषा का यह हिस्सा सिर्फ इस मामले के लिए बनाया गया था, इसलिए इसका लाभ उठाएं।

Answer 10

मैं अनुगामी अंडरस्कोर द्वारा वास्तविक सदस्यों को नाम दें, तो मैं ऐसा करते हैं:

Foo(int bar) : bar_(bar) { } 

कारण तो मैं getBar ऐसा कुछ बिना गेटर कार्यों का उपयोग कर सकते हैं() (बार() बेहतर है) है।

Answer 11

मैं इस तरह यह कार्य करें:

obj(int foo) : _foo(foo) { } 
int foo() const { return _foo; } 
void foo(int value) { _foo = value; } 

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

Answer 12

मैं पालन Google C++ Style Guide

चर नाम शब्दों के बीच अंडरस्कोर से, सभी लोअरकेस कर रहे हैं।कक्षा सदस्य चर के पीछे अंडरस्कोर पीछे है। उदाहरण के लिए: my_exciting_local_variable, my_exciting_member_variable_।