मैट प्राइस के समाधान पर विचार करें ।
- C ++ में, "स्थिर वर्ग" का कोई अर्थ नहीं है। निकटतम चीज केवल स्थिर विधियों और सदस्यों के साथ एक वर्ग है।
- स्थैतिक तरीकों का उपयोग केवल आपको सीमित करेगा।
, सी ++ अर्थ विज्ञान में व्यक्त अपने कार्य डाल करने के लिए (के लिए यह क्या आप चाहते हैं, है एक नाम स्थान में एक समारोह)।
2011-11-11 को संपादित करें
C ++ में कोई "स्थिर वर्ग" नहीं है। निकटतम अवधारणा केवल स्थिर विधियों वाला एक वर्ग होगा। उदाहरण के लिए:
// header
class MyClass
{
public :
static void myMethod() ;
} ;
// source
void MyClass::myMethod()
{
// etc.
}
लेकिन आपको याद रखना चाहिए कि जावा जैसी तरह की भाषाओं में "स्टैटिक क्लासेस" हैक होती हैं (जैसे C #) जो गैर-सदस्य फ़ंक्शंस करने में असमर्थ हैं, इसलिए उन्हें स्टैटिक विधियों के रूप में कक्षाओं के अंदर ले जाने के बजाय है।
C ++ में, जो आप वास्तव में चाहते हैं वह एक गैर-सदस्यीय फ़ंक्शन है जिसे आप एक नाम स्थान में घोषित करेंगे:
// header
namespace MyNamespace
{
void myMethod() ;
}
// source
namespace MyNamespace
{
void myMethod()
{
// etc.
}
}
ऐसा क्यों है?
C ++ में, नाम "जावा स्टैटिक मेथड" पैटर्न के लिए कक्षाओं की तुलना में अधिक शक्तिशाली है, क्योंकि:
- स्थिर विधियों में कक्षाओं के निजी प्रतीकों तक पहुंच है
- निजी स्थिर विधियाँ अभी भी सभी के लिए (यदि दुर्गम हैं) दिखाई दे रही हैं, जो कुछ हद तक एनकैप्सुलेशन को तोड़ती हैं
- स्थिर तरीकों को आगे घोषित नहीं किया जा सकता है
- लाइब्रेरी हेडर को संशोधित किए बिना स्थिर तरीकों को वर्ग उपयोगकर्ता द्वारा अधिभारित नहीं किया जा सकता है
- ऐसा कुछ भी नहीं है जो एक स्थिर विधि द्वारा किया जा सकता है जो एक ही नामस्थान में (संभवतः मित्र) गैर-सदस्य फ़ंक्शन से बेहतर नहीं किया जा सकता है
- नामस्थानों के अपने शब्दार्थ हैं (उन्हें जोड़ा जा सकता है, वे गुमनाम हो सकते हैं, आदि)
- आदि।
निष्कर्ष: C ++ में जावा / सी # पैटर्न को कॉपी / पेस्ट न करें। जावा / सी # में, पैटर्न अनिवार्य है। लेकिन C ++ में, यह खराब शैली है।
2010-06-10 संपादित करें
स्थैतिक विधि के पक्ष में एक तर्क था क्योंकि कभी-कभी, किसी को स्थिर निजी सदस्य चर का उपयोग करने की आवश्यकता होती है।
मैं कुछ हद तक असहमत हूं, जैसा कि नीचे दिखाया गया है:
"स्थैतिक निजी सदस्य" समाधान
// HPP
class Foo
{
public :
void barA() ;
private :
void barB() ;
static std::string myGlobal ;
} ;
सबसे पहले, myGlobal को myGlobal कहा जाता है क्योंकि यह अभी भी एक वैश्विक निजी चर है। CPP स्रोत पर एक नज़र स्पष्ट करेगी कि:
// CPP
std::string Foo::myGlobal ; // You MUST declare it in a CPP
void Foo::barA()
{
// I can access Foo::myGlobal
}
void Foo::barB()
{
// I can access Foo::myGlobal, too
}
void barC()
{
// I CAN'T access Foo::myGlobal !!!
}
पहली नजर में, तथ्य यह है कि नि: शुल्क फ़ंक्शन बारसी फू का उपयोग नहीं कर सकता है :: myGlobal एक एनकैप्सुलेशन दृष्टिकोण से एक अच्छी बात है ... यह अच्छा है क्योंकि एचपीपी को देखने वाला कोई भी व्यक्ति (जब तक कि तोड़फोड़ का सहारा नहीं ले सकता) तक पहुंच नहीं सकता है फू :: myGlobal।
लेकिन यदि आप इसे करीब से देखते हैं, तो आप पाएंगे कि यह एक भारी गलती है: न केवल आपके निजी चर को अभी भी एचपीपी में घोषित किया जाना चाहिए (और इसलिए, निजी होने के बावजूद सभी दुनिया के लिए दृश्यमान है), लेकिन आपको घोषित करना चाहिए एक ही एचपीपी में सभी (सभी के रूप में) कार्य जो इसे एक्सेस करने के लिए अधिकृत होंगे !!!
इसलिए एक निजी स्थिर सदस्य का उपयोग करना आपकी त्वचा पर टैटू किए गए प्रेमियों की सूची के साथ नग्न होकर बाहर घूमने जैसा है: कोई भी छूने के लिए अधिकृत नहीं है, लेकिन हर कोई झांकने में सक्षम है। और बोनस: हर किसी के पास आपके निजी के साथ खेलने के लिए अधिकृत लोगों के नाम हो सकते हैं।
private वास्तव में ...: -डॉ
"अनाम नामस्थान" समाधान
बेनामी नेमस्पेस में निजी तौर पर चीजों को निजी बनाने का फायदा होगा।
सबसे पहले, एचपीपी हेडर
// HPP
namespace Foo
{
void barA() ;
}
बस यह सुनिश्चित करने के लिए कि आपने टिप्पणी की है: न तो बारबी की कोई बेकार घोषणा है और न ही मायग्लोबल। जिसका अर्थ है कि हेडर को पढ़ने वाला कोई नहीं जानता कि बार के पीछे क्या छिपा है।
फिर, CPP:
// CPP
namespace Foo
{
namespace
{
std::string myGlobal ;
void Foo::barB()
{
// I can access Foo::myGlobal
}
}
void barA()
{
// I can access myGlobal, too
}
}
void barC()
{
// I STILL CAN'T access myGlobal !!!
}
जैसा कि आप देख सकते हैं, तथाकथित "स्थिर वर्ग" घोषणा की तरह, fooA और fooB अभी भी myGlobal तक पहुंचने में सक्षम हैं। लेकिन कोई और नहीं कर सकता। और इस सीपीपी के बाहर कोई और नहीं जानता कि fooB और myGlobal भी मौजूद है!
"स्टैटिक क्लास" के विपरीत, उसकी पता पुस्तिका में उसकी त्वचा पर टैटू वाली "अनाम" नाम की पुड़िया पूरी तरह से चढ़ी हुई है , जो काफी अच्छी तरह से AFAIK से घिरा हुआ लगता है।
क्या यह वास्तव में मायने रखता है?
जब तक आपके कोड के उपयोगकर्ता सबोटर्स नहीं होते हैं (मैं आपको एक अभ्यास के रूप में बताता हूं, यह पता लगाएं कि एक सार्वजनिक वर्ग के निजी हिस्से तक पहुंच कैसे एक गंदा व्यवहार-अपरिभाषित हैक का उपयोग कर सकता है ...), क्या privateहै private, भले ही वह क्या हो privateएक हेडर में घोषित एक वर्ग के अनुभाग में दिखाई देता है ।
फिर भी, अगर आपको निजी सदस्य तक पहुंच के साथ एक और "निजी फ़ंक्शन" जोड़ने की आवश्यकता है, तो आपको अभी भी हेडर को संशोधित करके इसे पूरी दुनिया के लिए घोषित करना होगा, जो कि एक विरोधाभास है जहां तक मेरा संबंध है: यदि मैं कार्यान्वयन को बदल देता हूं मेरा कोड (CPP भाग), तो इंटरफ़ेस (HPP भाग) को बदलना नहीं चाहिए। लियोनिदास का हवाला देते हुए: " यह उत्साह है! "
2014-09-20 संपादित करें
जब वर्ग स्थैतिक विधियाँ वास्तव में गैर-सदस्य कार्यों वाले नाम स्थान से बेहतर होती हैं?
जब आपको समूह में एक साथ कार्य करने की आवश्यकता हो और उस समूह को खाके पर फ़ीड करें:
namespace alpha
{
void foo() ;
void bar() ;
}
struct Beta
{
static void foo() ;
static void bar() ;
};
template <typename T>
struct Gamma
{
void foobar()
{
T::foo() ;
T::bar() ;
}
};
Gamma<alpha> ga ; // compilation error
Gamma<Beta> gb ; // ok
gb.foobar() ; // ok !!!
क्योंकि, यदि कोई वर्ग एक टेम्पलेट पैरामीटर हो सकता है, तो एक नाम स्थान नहीं हो सकता है।