कैसे पढ़ें:
यह लेख बल्कि लंबा है। यदि आप दोनों समुच्चय और POD (Plain Old Data) के बारे में जानना चाहते हैं तो समय निकालें और इसे पढ़ें। यदि आप केवल समुच्चय में रुचि रखते हैं, तो केवल पहले भाग को पढ़ें। यदि आप केवल PODs में रुचि रखते हैं तो आपको पहले समुच्चय की परिभाषा, निहितार्थ और उदाहरण पढ़ना चाहिए और फिर आप POD में कूद सकते हैं लेकिन मैं फिर भी इसकी संपूर्णता में पहला भाग पढ़ने की सलाह दूंगा। PODs को परिभाषित करने के लिए समुच्चय की धारणा आवश्यक है। यदि आपको कोई त्रुटि मिलती है (व्याकरण, शैलीविज्ञान, स्वरूपण, वाक्य रचना, आदि सहित मामूली भी) तो कृपया एक टिप्पणी छोड़ दें, मैं संपादित करूँगा।
यह उत्तर C ++ 03 पर लागू होता है। अन्य C ++ मानकों के लिए देखें:
समुच्चय क्या हैं और वे विशेष क्यों हैं
C ++ मानक से औपचारिक परिभाषा ( C ++ 03 8.5.1 : 1 ) :
कुल एक सरणी या एक वर्ग (खंड 9) है जिसमें कोई उपयोगकर्ता-घोषित निर्माता (12.1), कोई निजी या संरक्षित गैर-स्थैतिक डेटा सदस्य (खंड 11), कोई आधार वर्ग (खंड 10) और कोई आभासी कार्य नहीं है (10.3) )।
तो, ठीक है, चलो इस परिभाषा को पार्स करते हैं। सबसे पहले, कोई भी सरणी एक समुच्चय है। एक वर्ग भी हो सकता है अगर ... रुको! संरचनाओं या यूनियनों के बारे में कुछ नहीं कहा गया है, क्या वे समुच्चय नहीं हो सकते हैं? हा वो कर सकते है। सी ++ में, शब्द classसभी वर्गों, संरचनाओं और यूनियनों को संदर्भित करता है। तो, एक वर्ग (या संरचना, या संघ) एक समुच्चय है यदि और केवल अगर यह उपरोक्त परिभाषाओं से मानदंडों को पूरा करता है। इन मानदंडों का क्या मतलब है?
इसका मतलब यह नहीं है कि एक समग्र वर्ग में कंस्ट्रक्टर नहीं हो सकते हैं, वास्तव में यह एक डिफ़ॉल्ट कंस्ट्रक्टर और / या कॉपी कंस्ट्रक्टर हो सकता है जब तक कि वे संकलक द्वारा स्पष्ट रूप से घोषित किए जाते हैं, और उपयोगकर्ता द्वारा स्पष्ट रूप से नहीं।
कोई भी निजी या संरक्षित गैर-स्थैतिक डेटा सदस्य नहीं । आपके पास उतने निजी और संरक्षित सदस्य फ़ंक्शंस हो सकते हैं (लेकिन कंस्ट्रक्टर नहीं) और साथ ही कई निजी या संरक्षित स्टैटिक डेटा सदस्य और सदस्य फ़ंक्शंस जो आपको पसंद हैं और कुल वर्गों के नियमों का उल्लंघन नहीं करते हैं
एक समग्र वर्ग में एक उपयोगकर्ता-घोषित / उपयोगकर्ता-परिभाषित कॉपी-असाइनमेंट ऑपरेटर और / या विध्वंसक हो सकता है
एक सरणी एक समुच्चय है भले ही वह गैर-समुच्चय वर्ग प्रकार की एक सरणी हो।
अब कुछ उदाहरण देखते हैं:
class NotAggregate1
{
virtual void f() {} //remember? no virtual functions
};
class NotAggregate2
{
int x; //x is private by default and non-static
};
class NotAggregate3
{
public:
NotAggregate3(int) {} //oops, user-defined constructor
};
class Aggregate1
{
public:
NotAggregate1 member1; //ok, public member
Aggregate1& operator=(Aggregate1 const & rhs) {/* */} //ok, copy-assignment
private:
void f() {} // ok, just a private function
};
तुम्हें नया तरीका मिल गया है। अब देखते हैं कि समुच्चय कैसे विशेष होते हैं। वे, गैर-कुल वर्गों के विपरीत, घुंघराले ब्रेसिज़ के साथ आरंभीकृत किए जा सकते हैं {}। यह इनिशियलाइज़ेशन सिंटैक्स सामान्यतः सरणियों के लिए जाना जाता है, और हमने अभी सीखा कि ये एग्रीगेट हैं। तो, चलो उनके साथ शुरू करते हैं।
Type array_name[n] = {a1, a2, …, am};
यदि (m == n) सरणी
के i वें तत्व को i के साथ आरंभीकृत किया जाता
है यदि (m <n)
सरणी के पहले m तत्व 1 , 2 , ..., m और अन्यn - mतत्वों केसाथ आरंभीकृतहोते हैं। यदि संभव हो तो, मूल्य-आरंभीकृत (शब्द की व्याख्या के लिए नीचे देखें)
और यदि (एम> एन)
कंपाइलर एक
और त्रुटि जारी करेगा (यह ऐसा मामला है जब एन बिल्कुल भी निर्दिष्ट नहीं है int a[] = {1, 2, 3};)
का आकार सरणी (n) को m के बराबर माना जाता है, इसलिएint a[] = {1, 2, 3};इसके बराबर हैint a[3] = {1, 2, 3};
जब अदिश प्रकार (की एक वस्तु bool, int, char, double, संकेत, आदि) है मूल्य प्रारंभ इसका मतलब है कि इसके साथ आरंभ नहीं हो जाता 0कि प्रकार के लिए ( falseके लिए bool, 0.0के लिए doubleआदि)। जब उपयोगकर्ता घोषित डिफॉल्ट कंस्ट्रक्टर के साथ वर्ग प्रकार का ऑब्जेक्ट वैल्यू-इनिशियलाइज्ड होता है तो उसका डिफॉल्ट कंस्ट्रक्टर कहलाता है। यदि डिफॉल्ट कंस्ट्रक्टर को स्पष्ट रूप से परिभाषित किया जाता है, तो सभी नॉनस्टैटिक सदस्यों की पुनरावृत्ति मूल्य-आरंभिक होती है। यह परिभाषा अभेद्य और थोड़ी गलत है, लेकिन यह आपको मूल विचार देना चाहिए। एक संदर्भ को मूल्य-आरंभ नहीं किया जा सकता है। गैर-एग्रीगेट वर्ग के लिए मान-आरंभीकरण विफल हो सकता है, उदाहरण के लिए, क्लास में कोई उपयुक्त डिफ़ॉल्ट कंस्ट्रक्टर नहीं है।
सरणी आरंभीकरण के उदाहरण:
class A
{
public:
A(int) {} //no default constructor
};
class B
{
public:
B() {} //default constructor available
};
int main()
{
A a1[3] = {A(2), A(1), A(14)}; //OK n == m
A a2[3] = {A(2)}; //ERROR A has no default constructor. Unable to value-initialize a2[1] and a2[2]
B b1[3] = {B()}; //OK b1[1] and b1[2] are value initialized, in this case with the default-ctor
int Array1[1000] = {0}; //All elements are initialized with 0;
int Array2[1000] = {1}; //Attention: only the first element is 1, the rest are 0;
bool Array3[1000] = {}; //the braces can be empty too. All elements initialized with false
int Array4[1000]; //no initializer. This is different from an empty {} initializer in that
//the elements in this case are not value-initialized, but have indeterminate values
//(unless, of course, Array4 is a global array)
int array[2] = {1, 2, 3, 4}; //ERROR, too many initializers
}
अब देखते हैं कि कुल वर्गों को ब्रेसिज़ के साथ कैसे जोड़ा जा सकता है। उसी तरह बहुत सुंदर। सरणी तत्वों के बजाय हम गैर-स्थैतिक डेटा सदस्यों को वर्ग परिभाषा में उनकी उपस्थिति के क्रम में आरंभ करेंगे (वे परिभाषा के अनुसार सभी सार्वजनिक हैं)। यदि सदस्यों की तुलना में कम इनिशियलाइज़र हैं, तो बाकी वैल्यू-इनिशियलाइज़्ड हैं। यदि उन सदस्यों में से एक को मूल्य-प्रारंभ करना असंभव है जो स्पष्ट रूप से आरंभिक नहीं थे, तो हमें एक संकलन-समय त्रुटि मिलती है। यदि आवश्यकता से अधिक आरंभीक हैं, तो हमें एक संकलन-समय त्रुटि भी मिलती है।
struct X
{
int i1;
int i2;
};
struct Y
{
char c;
X x;
int i[2];
float f;
protected:
static double d;
private:
void g(){}
};
Y y = {'a', {10, 20}, {20, 30}};
ऊपर के उदाहरण में y.cसाथ आरंभ नहीं हो जाता 'a', y.x.i1साथ 10, y.x.i2साथ 20, y.i[0]साथ 20, y.i[1]साथ 30और y.fमूल्य-प्रारंभ, है कि, के साथ प्रारंभ है 0.0। संरक्षित स्थैतिक सदस्य dको आरंभिक नहीं किया जाता है, क्योंकि यह है static।
अलग-अलग यूनियन इस मायने में अलग हैं कि आप केवल अपने पहले सदस्य को ब्रेसिज़ के साथ शुरू कर सकते हैं। मुझे लगता है कि यदि आप यूनियनों का उपयोग करने पर विचार करने के लिए सी ++ में पर्याप्त उन्नत हैं (उनका उपयोग बहुत खतरनाक हो सकता है और ध्यान से सोचा जाना चाहिए), तो आप मानक में यूनियनों के नियमों को देख सकते हैं :)।
अब जब हम जानते हैं कि समुच्चय के बारे में क्या खास है, तो आइए कक्षाओं पर प्रतिबंध को समझने की कोशिश करें; यही कारण है, वे वहाँ क्यों हैं। हमें समझना चाहिए कि ब्रेसिज़ के साथ सदस्यवार आरंभ का तात्पर्य है कि वर्ग अपने सदस्यों के योग से अधिक कुछ नहीं है। यदि कोई उपयोगकर्ता-निर्धारित कंस्ट्रक्टर मौजूद है, तो इसका मतलब है कि सदस्यों को शुरू करने के लिए उपयोगकर्ता को कुछ अतिरिक्त काम करने की आवश्यकता है इसलिए ब्रेस इनिशियलाइज़ेशन गलत होगा। यदि वर्चुअल फ़ंक्शंस मौजूद हैं, तो इसका मतलब है कि इस वर्ग की वस्तुओं में (अधिकांश कार्यान्वयन पर) एक पॉइंटर तथाकथित वर्ग के समान है, जो कंस्ट्रक्टर में सेट है, इसलिए ब्रेस-इनिशियलाइज़ेशन अपर्याप्त होगा। आप एक अभ्यास के रूप में बाकी प्रतिबंधों का पता लगा सकते हैं :)।
इतना समुच्चय के बारे में पर्याप्त है। अब हम टाइप करने के लिए, PODs के कड़े सेट को परिभाषित कर सकते हैं
POD क्या हैं और वे विशेष क्यों हैं
C ++ मानक से औपचारिक परिभाषा ( C ++ 03 9 ) 4 ) :
POD- संरचना एक समग्र वर्ग है जिसमें गैर-POD- संरचना, गैर-POD- संघ (या इस प्रकार के सरणी) या संदर्भ के कोई भी गैर-स्थैतिक डेटा सदस्य नहीं होते हैं, और कोई उपयोगकर्ता-निर्धारित प्रतिलिपि असाइनमेंट ऑपरेटर और नहीं है उपयोगकर्ता-परिभाषित विध्वंसक। इसी तरह, एक POD- संघ एक समग्र संघ है जिसमें गैर-POD- संरचना, गैर POD- संघ (या इस प्रकार के सरणी) या संदर्भ के प्रकार के कोई गैर-स्थैतिक डेटा सदस्य नहीं होते हैं, और कोई उपयोगकर्ता-निर्धारित प्रतिलिपि असाइनमेंट ऑपरेटर नहीं होता है और कोई उपयोगकर्ता-परिभाषित विध्वंसक नहीं है। एक POD वर्ग एक ऐसा वर्ग है जो या तो POD- संरचना या POD- संघ है।
वाह, यह तोते के लिए मुश्किल है, है ना? :) आइए यूनियनों को बाहर छोड़ दें (ऊपर के रूप में उसी आधार पर) और थोड़ा स्पष्ट तरीके से रीफ़्रेज़ करें:
कुल वर्ग को POD कहा जाता है, यदि इसमें कोई उपयोगकर्ता-परिभाषित प्रतिलिपि-असाइनमेंट ऑपरेटर और विध्वंसक नहीं है और इसका कोई भी गैर-सदस्य सदस्य गैर-POD वर्ग, गैर-POD का सरणी या संदर्भ नहीं है।
इस परिभाषा का क्या अर्थ है? (क्या मैंने उल्लेख किया कि POD का मतलब प्लेन ओल्ड डेटा है ?)
- सभी POD क्लासेस एग्रीगेट हैं, या, इसे दूसरे तरीके से रखने के लिए, यदि कोई क्लास एग्रीगेट नहीं है, तो यह निश्चित है कि POD नहीं है
- कक्षाएं, केवल संरचनाओं की तरह, भले ही दोनों ही मामलों के लिए मानक शब्द POD- संरचना हो, लेकिन POD हो सकते हैं
- जैसे समुच्चय के मामले में, इससे कोई फर्क नहीं पड़ता कि वर्ग के पास स्थिर सदस्य क्या हैं
उदाहरण:
struct POD
{
int x;
char y;
void f() {} //no harm if there's a function
static std::vector<char> v; //static members do not matter
};
struct AggregateButNotPOD1
{
int x;
~AggregateButNotPOD1() {} //user-defined destructor
};
struct AggregateButNotPOD2
{
AggregateButNotPOD1 arrOfNonPod[3]; //array of non-POD class
};
POD- क्लासेस, POD-unions, scalar types और इस तरह के सरणियों को सामूहिक रूप से POD- प्रकार कहा जाता है ।
POD कई मायनों में खास हैं। मैं सिर्फ कुछ उदाहरण प्रदान करता हूँ।
POD- क्लास C स्ट्रक्चर्स के सबसे करीब हैं। उनके विपरीत, पीओडी में सदस्य कार्य और मनमाने ढंग से स्थिर सदस्य हो सकते हैं, लेकिन इन दोनों में से कोई भी वस्तु का मेमोरी लेआउट नहीं बदलता है। इसलिए यदि आप अधिक या कम पोर्टेबल डायनेमिक लाइब्रेरी लिखना चाहते हैं जिसका उपयोग C और यहां तक कि .NET से किया जा सकता है, तो आपको अपने सभी निर्यात किए गए कार्यों को लेने और POD- प्रकार के केवल मापदंडों को वापस करने की कोशिश करनी चाहिए।
गैर-पीओडी वर्ग प्रकार की वस्तुओं का जीवनकाल तब शुरू होता है जब निर्माणकर्ता समाप्त हो गया है और तब समाप्त होता है जब विध्वंसक समाप्त हो जाता है। POD क्लासेस के लिए, जीवनकाल तब शुरू होता है जब ऑब्जेक्ट के लिए स्टोरेज पर कब्जा कर लिया जाता है और उस स्टोरेज को रिजेक्ट या रिजेक्ट कर दिया जाता है।
POD प्रकारों की वस्तुओं के लिए यह मानक द्वारा गारंटी दी जाती है कि जब आप memcpyअपनी वस्तु की सामग्री को चार या असेंबली चार की श्रेणी में रखते हैं, और फिर memcpyसामग्री वापस आपकी वस्तु में आ जाती है, तो वस्तु अपने मूल मूल्य को धारण करेगी। ध्यान दें कि गैर-पीओडी प्रकारों की वस्तुओं के लिए ऐसी कोई गारंटी नहीं है। इसके अलावा, आप सुरक्षित रूप से POD ऑब्जेक्ट्स की प्रतिलिपि बना सकते हैं memcpy। निम्नलिखित उदाहरण मानता है कि T एक POD- प्रकार है:
#define N sizeof(T)
char buf[N];
T obj; // obj initialized to its original value
memcpy(buf, &obj, N); // between these two calls to memcpy,
// obj might be modified
memcpy(&obj, buf, N); // at this point, each subobject of obj of scalar type
// holds its original value
गोटो बयान। जैसा कि आप जानते हैं, यह गैरकानूनी है (कंपाइलर को एक त्रुटि जारी करनी चाहिए) एक बिंदु से गोटो के माध्यम से एक छलांग लगाने के लिए जहां कुछ चर अभी तक एक बिंदु के दायरे में नहीं था जहां यह पहले से ही गुंजाइश है। यह प्रतिबंध केवल तभी लागू होता है जब चर गैर-पीओडी प्रकार का होता है। निम्नलिखित उदाहरण f()में बीमार है, जबकि g()अच्छी तरह से गठित है। ध्यान दें कि Microsoft का कंपाइलर इस नियम से बहुत उदार है - यह दोनों मामलों में एक चेतावनी जारी करता है।
int f()
{
struct NonPOD {NonPOD() {}};
goto label;
NonPOD x;
label:
return 0;
}
int g()
{
struct POD {int i; char c;};
goto label;
POD x;
label:
return 0;
}
यह गारंटी है कि एक POD ऑब्जेक्ट की शुरुआत में कोई पैडिंग नहीं होगी। दूसरे शब्दों में, अगर एक पॉड स्तरीय एक का पहला सदस्य प्रकार टी की है, तो आप सुरक्षित रूप से कर सकते हैं reinterpret_castसे A*करने के लिए T*और सूचक प्राप्त पहले सदस्य और इसके विपरीत।
यह सूची लम्बी होते चली जाती है…
निष्कर्ष
यह समझना महत्वपूर्ण है कि वास्तव में एक POD क्या है क्योंकि कई भाषा सुविधाएँ, जैसा कि आप देखते हैं, उनके लिए अलग तरह से व्यवहार करते हैं।