एवरग्रीक कंपाइलर सी ++ का समर्थन करता है, हालांकि, इसकी डिलीवरी में मानक पुस्तकालय या एबीआई का कार्यान्वयन शामिल नहीं है: उपयोगिता फ़ंक्शन, कॉल जो कंपाइलर द्वारा ही डाले जाते हैं। नतीजतन, लोग उन हिस्सों को महसूस करने की कोशिश करते हैं जो उन्हें अपने दम पर चाहिए होते हैं और अक्सर यह बहुत अच्छा नहीं होता है। उदाहरण के लिए, अक्सर यह सुझाव दिया जाता है कि आप खाली टास्क __cxa_pure_virtual (शून्य) {} को परिभाषित करके अपने पैर को गोली मारते हैं या __cxa_guard_acquire, __cxa_guard_release और __cxa_guard_abort के लिए स्टब्स लिखकर खुद को रेक बना लेते हैं। इस लेख में, मैं यह पता लगाने का प्रस्ताव करता हूं कि खुशी के लिए क्या गायब है, इसे कहां प्राप्त करें या इसे कैसे लिखें।
मुझे पता है कि काफी लोगों को लगता है कि माइक्रोकंट्रोलर पर C ++ की आवश्यकता नहीं है। मैं उनसे टिप्पणी लिखने से पहले लेख के अंतिम खंड को पढ़ने के लिए कहता हूं।

Arduino के मालिकों के लिए सुविधाएँ

Arduino सीमित C ++ सहायता प्रदान करता है। लेकिन, जैसा कि मैं इसे समझता हूं, arduino डेवलपर्स को C ++ पसंद नहीं है, इसलिए, श्रमिकों के अनुरोध पर, पहले पकड़े गए बैसाखी को संबंधित मॉड्यूल में डाला गया था। यह avrfreaks पर वर्णित बैसाखी निकला, और विषय में टिप्पणियों में निर्दिष्ट सुधारों के बिना। इसलिए, पहले आपको इससे छुटकारा पाना होगा। फ़ाइलों को हटा दें

हार्डवेयर / arduino / कोर / arduino / new.h
हार्डवेयर / arduino / कोर / arduino / new.cpp

या उस संस्करण का उपयोग करें जहां यह पहले से ही किया गया है ।

विशुद्ध रूप से आभासी और दूरस्थ तरीके

आभासी तरीकों का तंत्र आमतौर पर व्यवहार्य के माध्यम से लागू किया जाता है। यह मानक द्वारा विनियमित नहीं है, लेकिन सभी संकलक द्वारा उपयोग किया जाता है। यहां तक कि अगर आप एक विधि को पूरी तरह से आभासी घोषित करते हैं, अर्थात, कोई कार्यान्वयन नहीं है, तो इस पद्धति के लिए पॉइंटर में एक पॉइंटर की जगह होगी। बाल कक्षाओं के लिए एक ही ऑफसेट पर संबंधित कार्यान्वयन के लिए एक संकेतक लगाने के लिए यह आवश्यक है। एक संकेतक के बजाय एक लापता विधि के लिए, कंपाइलर स्टब फ़ंक्शन के लिए एक सूचक लिखता है __cxa_pure_virtual vtable में। यदि कोई विशुद्ध रूप से आभासी फ़ंक्शन को कॉल करने का प्रबंधन करता है, तो नियंत्रण स्टब पर जाएगा और यह मेमोरी के यादृच्छिक टुकड़े को निष्पादित करने के बजाय कार्यक्रम को रोक देगा। कृपया ध्यान दें कि यह सुरक्षा लगभग मुफ्त है: __cxa_pure_virtual कार्यान्वयन, जिसमें एक एकल कॉल है, केवल 6 बाइट्स का फ्लैश लेता है।
एक वाजिब सवाल उठता है, लेकिन एक विशुद्ध रूप से आभासी फ़ंक्शन को कैसे कहा जा सकता है अगर एक अमूर्त वर्ग की वस्तु बनाना असंभव है? आप इसे नहीं बना सकते हैं, लेकिन यदि आप अजीब कोड लिखते हैं तो आप इसे कॉल कर सकते हैं:

class B { public: B() { //   C   ,   vtable  B //        ,  //        virt(),    non_virtual(); } void non_virtual() { //       ,     //      ,   //    B virt(); // pure virtual method called // terminate called without an active exception //   (core dumped) } virtual void virt() = 0; }; class C : public B{ public: virtual void virt() {} }; int main(int argc, char** argv) { C c; return 0; }

ऐसी त्रुटियों से बचने के लिए, हमें प्रयास करना चाहिए कि ऑब्जेक्ट के तरीकों को तब तक न कहा जाए जब तक कि इसे प्रारंभ न कर दिया जाए। दूसरे शब्दों में, आपको कंस्ट्रक्टर में कड़ी मेहनत नहीं करनी है। और ताकि कंपाइलर आपके आवेदन का निर्माण करे, निम्नलिखित कार्यों का कार्यान्वयन जोड़ें:

 void __cxa_pure_virtual(void) { // We might want to write some diagnostics to uart in this case std::terminate(); } void __cxa_deleted_virtual(void) { // We might want to write some diagnostics to uart in this case std::terminate(); }

आपको मानक पुस्तकालय से std :: समाप्त करने के कार्यान्वयन की भी आवश्यकता होगी। यदि आपको वास्तव में 2 बाइट्स रैम और 14 बाइट्स फ्लैश को बचाने की आवश्यकता है, तो आप सीधे गर्भपात () कॉल कर सकते हैं, लेकिन बाद में मैं समझाऊंगा कि std :: terminate बेहतर क्यों है।

स्थैतिक चर

आप किसी फ़ंक्शन के अंदर एक वैरिएबल को स्टैटिक घोषित कर सकते हैं, जो वास्तव में अपने ग्लोबल वैरिएबल को केवल फंक्शन के अंदर दिखाई देगा।

 int counter(int start) { static int cnt = start; return ++cnt; }

सी में, इस कोड को संकलित नहीं किया जाएगा, क्योंकि स्थैतिक चर को प्रारंभिक मान के साथ आरंभ किया जाना चाहिए, ताकि तत्काल मान को .data अनुभाग में रखा जा सके। C ++ में, यह अनुमति दी गई थी, लेकिन यह निर्दिष्ट नहीं किया गया था कि क्या होगा यदि दो थ्रेड्स ने एक ही समय में चर को इनिशियलाइज़ करने की कोशिश की। कई संकलक ने इस मामले में ताले जोड़ने और थ्रेड सुरक्षा प्रदान करने के लिए चुना है, और सी ++ 11 में यह व्यवहार मानक का हिस्सा बन गया है। इसलिए, एक स्थिर चर gcc के गैर-स्थिर मान के साथ प्रारंभ करना निम्नलिखित कोड में विस्तार करेगा: gcc / cp / घोषण।

 static <type> guard; if (!guard.first_byte) { if (__cxa_guard_acquire (&guard)) { bool flag = false; try { // Do initialization. flag = true; __cxa_guard_release (&guard); // Register variable for destruction at end of program. } catch { if (!flag) __cxa_guard_abort (&guard); } } }

जहां गार्ड एक पूर्णांक प्रकार होता है जो ध्वज और म्यूटेक्स को पकड़ने के लिए पर्याप्त होता है। Gcc के सूत्रों पर एक नज़र से पता चला कि इसका अनुकूलन केवल ARM आर्किटेक्चर से परेशान था:
gcc / config / arm / arm.c

 /* The generic C++ ABI says 64-bit (long long). The EABI says 32-bit. */ static tree arm_cxx_guard_type (void) { return TARGET_AAPCS_BASED ? integer_type_node : long_long_integer_type_node; }

अन्य सभी मामलों में, डिफ़ॉल्ट प्रकार का उपयोग किया जाता है: long_long_integer_type_node। Avr पर, -mint8 विकल्प के आधार पर, यह या तो 64 या 32 बिट्स का होगा। 16. guard.first_byte, जिसमें झंडा लगाया गया है, हमारे लिए पर्याप्त है, इसे कंपाइलर द्वारा सबसे कम पते वाले बाइट के रूप में समझा जाता है: * (reinterpret_cast <char *> (g))। एक अपवाद एआरएम प्लेटफॉर्म है, जहां पहले बाइट का केवल एक बिट उपयोग किया जाता है।

कैसे सही है?

यदि आपको थ्रेड सुरक्षित स्थिर चर की आवश्यकता नहीं है, तो उन्हें -fno-threadsafe-statics विकल्प के साथ अक्षम करें और जटिल ताले के बजाय संकलक एक साधारण ध्वज जांच सेट करेगा। इस मामले में __cxa_guard_ * को लागू करने की कोई आवश्यकता नहीं है। लेकिन अगर आप उन्हें प्रदान करते हैं (जैसा कि arduino में किया जाता है), तो कार्यान्वयन को सही संचालन सुनिश्चित करना चाहिए यदि चर को नियमित कोड से और एक रुकावट से एक साथ शुरू किया गया हो। दूसरे शब्दों में, __cxa_guard_acquire को बीच में रोकना चाहिए, और __cxa_guard_release और __cxa_guard_abort को उन्हें उनकी पिछली स्थिति में वापस करना चाहिए। आरटीओएस के मामले में, मैं संभवत: दो थ्रेड्स के लिए शुद्धता छोड़कर, इंटरप्ट में शुद्धता का त्याग करने के लिए तैयार हूं। सही कार्यान्वयन इस तरह काम करना चाहिए:

 namespace { // guard is an integer type big enough to hold flag and a mutex. // By default gcc uses long long int and avr ABI does not change it // So we have 32 or 64 bits available. Actually, we need 16. inline char& flag_part(__guard *g) { return *(reinterpret_cast<char*>(g)); } inline uint8_t& sreg_part(__guard *g) { return *(reinterpret_cast<uint8_t*>(g) + sizeof(char)); } } int __cxa_guard_acquire(__guard *g) { uint8_t oldSREG = SREG; cli(); // Initialization of static variable has to be done with blocked interrupts // because if this function is called from interrupt and sees that somebody // else is already doing initialization it MUST wait until initializations // is complete. That's impossible. // If you don't want this overhead compile with -fno-threadsafe-statics if (flag_part(g)) { SREG = oldSREG; return false; } else { sreg_part(g) = oldSREG; return true; } } void __cxa_guard_release (__guard *g) { flag_part(g) = 1; SREG = sreg_part(g); } void __cxa_guard_abort (__guard *g) { SREG = sreg_part(g); }

कितना?

यदि आप स्थैतिक चर का उपयोग नहीं करते हैं या उन्हें निरंतर मान प्रदान करते हैं, तो यह मुफ़्त है। यदि आप -fno-threadsafe-statics फ़्लैग को निर्दिष्ट करते हैं, तो फ़्लैग के लिए 8 बाइट्स RAM और प्रत्येक वेरिएबल के लिए 12 बाइट्स का भुगतान करें। यदि आप थ्रेड-सुरक्षित इनिशियलाइज़ेशन का उपयोग करते हैं, तो प्रत्येक चर के लिए फ्लैश के 38 बाइट्स और पूरे कार्यक्रम के लिए एक और 44 खर्च करें। इसके अलावा, स्थैतिक चर के प्रारंभ के दौरान रुकावटों को अवरुद्ध किया जाएगा। लेकिन आप डिजाइनरों में मुश्किल काम नहीं करते हैं?
पसंद आपकी है, लेकिन किसी भी मामले में, यदि पुस्तकालय __cxa_guard_ * फ़ंक्शन प्रदान करता है, तो उन्हें सही तरीके से लागू किया जाना चाहिए, और प्लग नहीं होना चाहिए जो हर जगह पेश किया जाता है। सामान्य तौर पर, मेरा सुझाव है कि आप स्थिर चर का उपयोग न करने का प्रयास करें।

कहाँ से लाऊँ?

abi.h और abi.cpp

ऑपरेटर नया और ऑपरेटर हटाएं

जब यह नए और हटाने वाले ऑपरेटरों की बात आती है, तो कोई निश्चित रूप से कहेगा कि माइक्रोकंट्रोलर्स के पास बहुत कम मेमोरी है, इसलिए डायनेमिक मेमोरी एक अभेद्य लक्जरी है। ये लोग नहीं जानते कि नए और डिलीट न केवल डायनेमिक मेमोरी मैनेजमेंट हैं। प्लेसमेंट नया भी है, प्रोग्रामर द्वारा आवंटित बफर में ऑब्जेक्ट की स्थिति। इसके बिना, आप फर्मवेयर के डेवलपर्स द्वारा प्रिय को रिंग बफर नहीं लिख सकते हैं, जिसके माध्यम से संदेश कतारें लागू की जाती हैं। ठीक है, यदि आप सुनिश्चित हैं कि गतिशील मेमोरी की आवश्यकता नहीं है, तो आपने मॉलोक और मुफ्त के लिए कार्यान्वयन क्यों लिखा? इसलिए ऐसे कार्य हैं जहां उनके बिना करना असंभव था।

नए और हटाए गए ऑपरेटरों के प्रकार

सबसे पहले, एकल ऑब्जेक्ट्स के लिए ऑपरेटर नई आवंटन मेमोरी है और एरर्स के लिए मेमोरी आवंटित करते हुए ऑपरेटर नया [] है। तकनीकी रूप से, वे उस नए में भिन्न होते हैं [] जब वह हटाए जाने पर प्रत्येक तत्व के लिए विध्वंसक को कॉल करने के लिए सरणी के आकार को याद करता है। इसलिए, मेमोरी को मुक्त करते समय [] जोड़ीदार ऑपरेटर को हटाने या ऑपरेटर को हटाने का उपयोग करना महत्वपूर्ण है।
दूसरे, इनमें से प्रत्येक ऑपरेटर, C ++ में किसी भी फ़ंक्शन की तरह, ओवरलोड हो सकता है। और मानक तीन विकल्पों को परिभाषित करता है:

```
 void* operator new(std::size_t numBytes) throw(std::bad_alloc); 
```
आकार के एक स्मृति ब्लॉक आवंटित करता है। त्रुटि के मामले में, एक अपवाद std :: bad_alloc फेंकता है
```
 void* operator new(std::size_t numBytes, const std::nothrow_t& ) throw(); 
```
आकार के एक स्मृति ब्लॉक आवंटित करता है। किसी त्रुटि के मामले में, अशक्त देता है
```
 inline void* operator new(std::size_t, void* ptr) throw() {return ptr; } 
```
प्लेसमेंट नया, वह वस्तु रखता है जहाँ उन्होंने कहा था। कंटेनरों को लागू करते समय उपयोग किया जाता है

Arduino में, अज्ञात कारणों से, केवल void * ऑपरेटर नया (std :: size_t numBytes) थ्रो (std :: bad_alloc) कार्यान्वित किया जाता है, और एक त्रुटि के मामले में, यह 0 देता है, जो बिना किसी प्रोग्राम के अपरिवर्तित प्रोग्राम व्यवहार की ओर जाता है, क्योंकि कोई भी लौटा हुआ मान नहीं देखता है। ।
ऑपरेटर को हटाने के साथ, चीजें थोड़ी पेचीदा होती हैं। शून्य * ऑपरेटर डिलीट (std :: size_t numBytes) और void * ऑपरेटर डिलीट [] (std :: size_t numBytes) हैं। आप इसे अन्य मापदंडों के लिए अधिभारित कर सकते हैं, लेकिन आप इन अधिभारों को नहीं कह सकते हैं, क्योंकि भाषा में संबंधित सिंटैक्स नहीं है। केवल एक ही मामला है जहां कंपाइलर डिलीट ऑपरेटर के ओवरलोडेड संस्करणों को आमंत्रित करेगा। कल्पना करें कि आप गतिशील मेमोरी में एक ऑब्जेक्ट बनाते हैं, नए ऑपरेटर ने मेमोरी को सफलतापूर्वक आवंटित किया, निर्माणकर्ता ने इसे भरना शुरू कर दिया और एक अपवाद फेंक दिया। आपका कोड अभी तक एक वस्तु के लिए एक संकेतक के निपटान में नहीं मिला है, ताकि यह सिस्टम में विफल वस्तु की स्मृति को वापस न कर सके। इसलिए, कंपाइलर को कॉल डिलीट करके ऐसा करने के लिए मजबूर किया जाता है। लेकिन क्या होता है यदि मेमोरी को प्लेसमेंट नए का उपयोग करके "आवंटित" किया गया है? इस स्थिति में, आप साधारण डिलीट को कॉल नहीं कर सकते हैं, इसलिए, यदि कंस्ट्रक्टर अपवाद फेंकता है, तो कंपाइलर डिलीट के ओवरलोडेड वर्जन को उन्हीं मापदंडों के साथ कॉल करेगा, जिसके साथ नया कहा गया था। इसलिए मानक पुस्तकालय ऑपरेटर के तीन संस्करणों को हटाता है और ऑपरेटर के तीन संस्करणों को हटाता है []।

ख़राब_लोक संभालना

जैसा कि ऊपर उल्लेख किया गया है, त्रुटि के मामले में अपवाद को फेंकने के लिए नए का सबसे अधिक इस्तेमाल किया जाने वाला संस्करण आवश्यक है। लेकिन gcc avr पर अपवादों का समर्थन नहीं करता: उन्हें फेंका या पकड़ा नहीं जा सकता। लेकिन अगर उन्हें पकड़ा नहीं जा सकता है, तो कार्यक्रम में एक भी कोशिश खंड नहीं है, जिसका अर्थ है कि यदि अपवाद फेंक दिया गया था, तो std :: terminate कहा जाएगा। इसके अलावा, सी ++ मानक इस मामले में अनुमति देता है (देखें 15.5.1) स्टैक को खोलना नहीं। इसलिए, नया std :: को सीधे कॉल कर सकता है और यह मानक के अनुरूप होगा।
डरो मत कि मानक पुस्तकालय फर्मवेयर ले जाएगा और पूरा करेगा! ख़राब_लोक होने पर आप कितनी बार कुछ ठीक कर सकते हैं? आमतौर पर कुछ भी नहीं। आपका फर्मवेयर सही संचालन को जारी नहीं रख सकता है और भगवान को धन्यवाद देता है कि त्रुटि होने पर यह पूरा हो जाएगा। लेकिन अगर आप जानते हैं कि स्थिति को कैसे ठीक किया जाए, तो आप नए ऑपरेटर के नोटह्रो संस्करण का उपयोग कर सकते हैं। इसे एक सुरक्षित मालॉक के रूप में देखें, यदि आप इसके द्वारा लौटाए गए मूल्य की जांच नहीं करते हैं तो सही ढंग से व्यवहार करना।

कहाँ से लाऊँ?

UClibc ++ में नए और डिलीट का पूर्ण और सही कार्यान्वयन है। सच है, std के बजाय :: terminate, abort () कहा जाता है। इसलिए मैंने एक संशोधित संस्करण बनाया। उसी समय, इनिशियलाइज़ेशन लिस्ट्स, std :: Move and std :: forvard, वहाँ जोड़े गए।

std :: समाप्ति बनाम गर्भपात ()

Avr-libc पर प्रलेखन के अनुसार, एबॉर्ट () फ़ंक्शन सभी अवरोधों को रोकता है, जिसके बाद यह एक अनंत लूप में आता है। यह वह नहीं है जो मैं चाहूंगा। दो कारणों से। सबसे पहले, यह डिवाइस को खतरनाक स्थिति में छोड़ देता है। कल्पना करें कि सिस्टम हीटिंग तत्व को नियंत्रित करता है और कार्यक्रम उस समय चक्र में जाता है जब इसे चालू किया जाता है। त्रुटि के मामले में, मैं बोर्ड के सभी आउटपुट को 0. पर सेट करके एक सुरक्षित स्थिति में स्विच करना चाहता हूं। दूसरा, मुझे पहले से ही पता है कि सब कुछ खराब है और मुझे तब तक इंतजार करने की आवश्यकता नहीं है जब तक कि वॉचडॉग काम नहीं करता है और सिस्टम को रिबूट करता है। यह तुरंत किया जा सकता है।
यदि फर्मवेयर std :: समाप्त कर देता है, तो मैं अपना हैंडलर स्थापित कर सकता हूं और वहां सभी आवश्यक कार्य कर सकता हूं। मैं गर्भपात को ओवरराइड नहीं कर सकता: यूनिक्स में इसके लिए दिया गया तंत्र एवीआर पर काम नहीं करता है। इसलिए, मैं उन 2 बाइट्स रैम और फ्लैश के 14 बाइट्स को बेहतर ढंग से खर्च करता हूं जो कि std :: समाप्त कार्यान्वयन में व्याप्त हैं।

अपवाद

अपवाद - C ++ का वह हिस्सा जिसके लिए आपको बहुत अधिक भुगतान करना पड़ता है, न केवल उस कोड में जो उन्हें सीधे उपयोग करता है, बल्कि उस कोड में भी जिसके माध्यम से अपवाद उड़ सकता है: संकलक को स्टैक पर बनाए गए प्रत्येक चर के विध्वंसक को पंजीकृत करने के लिए मजबूर किया जाता है। इसके अलावा, अपवादों के लिए, आपको RTTI और एक छोटे बैकअप मेमोरी बफर की आवश्यकता होती है, इसलिए यह वह जगह है जहाँ मेमोरी बनाने के लिए std :: bad_alloc बनाया जाता है। इसके अलावा, यह सी ++ का एकमात्र हिस्सा है जिसके लिए यह समस्याग्रस्त है, हालांकि रनटाइम की गणना करना असंभव नहीं है। जहां तक मैं समझता हूं, जो कोई भी एवीआर पर लापता अपवाद समर्थन कार्यों को लिखने के लिए पर्याप्त समझता है, उसे ऐसा करने की कोई इच्छा नहीं है। कई और महत्वपूर्ण काम भी करने हैं। इसलिए, gcc में AVR पर अपवादों का कोई समर्थन नहीं है, और संभावना है कि यह नहीं होगा।

एसटीएल

मैंने कई रिपोर्टों को देखा है कि माइक्रोकंट्रोलर पर एसटीएल खराब है: यह कोड को फुलाता है और जटिल चीजों को सरल बनाता है, उन्हें उपयोग करने के लिए उकसाता है। इसी समय, यह मौन है कि एसटीएल में त्वरित छँटनी के रूप में ऐसी प्राइमेटीज़ भी हैं, जो कि qsort, या बाइनरी सर्च , मिन और मैक्स के सुरक्षित संस्करणों की तुलना में बहुत तेज़ और अधिक कॉम्पैक्ट है। क्या आप वास्तव में शास्त्रीय एल्गोरिदम को अन्य प्रोग्रामर की तुलना में अधिक कुशलता से लिखने का पवित्र तरीका जानते हैं? और फिर एक तैयार-किए गए परीक्षण एल्गोरिथ्म का उपयोग क्यों न करें जो आपको लिखना है जितना अधिक स्थान लेता है। एसटीएल के उन हिस्सों के लिए जिनका आप उपयोग नहीं करते हैं, आप भुगतान नहीं करते हैं।

कहाँ से लाऊँ?

UClibc ++ का उपयोग करें। इस लाइब्रेरी में एक विशेषता है: std :: map और std :: सेट को वेक्टर के शीर्ष पर लागू किया जाता है, इसलिए इसे डालने और हटाने के दौरान पुनरावृत्तियों को निष्क्रिय कर दिया जाता है। इसके अलावा, उनकी एक अलग जटिलता है। प्रलेखन में, लेखक ने विस्तार से वर्णन किया कि उसने ऐसा क्यों किया।

C ++ किस लिए है?

यह एक अलग लेख के लिए एक विषय है, जिसे मैं रुचि रखने पर लिखने के लिए तैयार हूं। संक्षेप में, जब सही ढंग से उपयोग किया जाता है , तो C ++ आपको समाधानों को C समाधानों के रूप में कुशल लिखने की अनुमति देता है, लेकिन एक ही समय में कोड प्राप्त होता है जो संकलक चेक के कारण अधिक पठनीय और सुरक्षित होता है। और टेम्पलेट तंत्र आपको सामान्यीकृत एल्गोरिदम के प्रभावी कार्यान्वयन को लिखने की अनुमति देता है, जो सी में समस्याग्रस्त है और मैं इसका उपयोग कर रहा हूं। किसी भी मामले में, मैं आपसे इस विषय पर चर्चा करने से परहेज करने का आग्रह करता हूं।

G ++ में avr के लिए C ++ सपोर्ट

Arduino के मालिकों के लिए सुविधाएँ

विशुद्ध रूप से आभासी और दूरस्थ तरीके

स्थैतिक चर

कैसे सही है?

कितना?

कहाँ से लाऊँ?

ऑपरेटर नया और ऑपरेटर हटाएं

नए और हटाए गए ऑपरेटरों के प्रकार

ख़राब_लोक संभालना

कहाँ से लाऊँ?

std :: समाप्ति बनाम गर्भपात ()

अपवाद

एसटीएल

कहाँ से लाऊँ?

C ++ किस लिए है?

More articles: