ऐसा कोई फायदा नहीं है जो मैं सोच सकता हूं (लेकिन नीचे जेसन को देखें), एक फ़ंक्शन या सबरूटीन के रूप में कोड की एक पंक्ति को लपेटता है। सिवाय शायद कि आप फ़ंक्शन को "पठनीय" नाम दे सकें। लेकिन आप बस के रूप में अच्छी तरह से लाइन टिप्पणी कर सकते हैं। और चूंकि किसी फ़ंक्शन में कोड की एक पंक्ति को लपेटने से कोड मेमोरी, स्टैक स्पेस और निष्पादन समय का खर्च होता है, इसलिए मुझे लगता है कि यह ज्यादातर काउंटर-उत्पादक है। एक शिक्षण स्थिति में? यह कुछ मतलब हो सकता है। लेकिन यह छात्रों की कक्षा, उनकी तैयारी पहले से, पाठ्यक्रम और शिक्षक पर निर्भर करता है। ज्यादातर, मुझे लगता है कि यह एक अच्छा विचार नहीं है। लेकिन यह मेरी राय है।
जो हमें लब्बोलुआब में लाता है। आपका व्यापक प्रश्न क्षेत्र दशकों से, कुछ बहस का विषय रहा है और आज भी कुछ बहस का विषय बना हुआ है। इसलिए, कम से कम जैसा कि मैंने आपके प्रश्न को पढ़ा है, यह मुझे एक राय-आधारित प्रश्न प्रतीत होता है (जैसा आपने पूछा था।)
इसे राय-आधारित होने से दूर ले जाया जा सकता है, क्योंकि यदि आप स्थिति के बारे में अधिक विस्तृत होना चाहते हैं और ध्यान से वर्णित उद्देश्यों को प्राथमिक मानते हैं। जितना बेहतर आप अपने माप उपकरणों को परिभाषित करेंगे, उतने अधिक उद्देश्य उत्तर हो सकते हैं।
मोटे तौर पर, आप किसी भी कोडिंग के लिए निम्नलिखित करना चाहते हैं । (नीचे के लिए, मैं मान लूंगा कि हम विभिन्न दृष्टिकोणों की तुलना कर रहे हैं, जिनमें से सभी लक्ष्यों को प्राप्त करते हैं। जाहिर है, कोई भी कोड जो आवश्यक कार्यों को पूरा करने में विफल रहता है, वह उस कोड की तुलना में खराब होता है जो सफल होता है, चाहे वह कैसा भी हो।
- अपने दृष्टिकोण के बारे में लगातार रहें, ताकि आपके कोड को पढ़ने वाला एक समझ विकसित कर सके कि आप अपनी कोडिंग प्रक्रिया के बारे में क्या सोचते हैं। असंगत होना शायद सबसे बुरा संभव अपराध है। यह न केवल दूसरों के लिए मुश्किल बनाता है, बल्कि खुद के लिए कोड वर्षों बाद वापस आना मुश्किल बनाता है।
- डिग्री के लिए संभव है, चीजों को आज़माएं और व्यवस्थित करें ताकि ऑर्डर देने के संबंध में विभिन्न कार्यात्मक वर्गों का आरंभ किया जा सके। जहां ऑर्डर करने की आवश्यकता होती है, अगर यह दो उच्च संबंधित उप-युग्मों के करीबी युग्मन के कारण है , तो दोनों के लिए एक एकल आरंभीकरण पर विचार करें ताकि इसे नुकसान पहुंचाए बिना फिर से व्यवस्थित किया जा सके। यदि यह संभव नहीं है, तो आरम्भिकरण आदेश की आवश्यकता का दस्तावेजीकरण करें।
- Encapsulate ज्ञान वास्तव में एक ही स्थान पर, यदि संभव हो तो। लगातार कोड में सभी जगह नकल नहीं की जानी चाहिए। कुछ चर के लिए हल करने वाले समीकरण एक और एक ही स्थान पर मौजूद होने चाहिए। और इसी तरह। यदि आप अपने आप को लाइनों के कुछ सेट को कॉपी और पेस्ट करते हुए पाते हैं, जो विभिन्न स्थानों पर कुछ आवश्यक व्यवहार करते हैं, तो उस ज्ञान को एक स्थान पर कब्जा करने और जहां जरूरत हो, वहां उपयोग करने के तरीके पर विचार करें। उदाहरण के लिए, यदि आपके पास एक पेड़ की संरचना है जिसे एक विशिष्ट तरीके से चलना चाहिए, तो नहींप्रत्येक स्थान पर ट्री-वॉकिंग कोड को दोहराएं जहां आपको ट्री नोड्स के माध्यम से लूप की आवश्यकता होती है। इसके बजाय, ट्री-वॉकिंग विधि को एक स्थान पर कैप्चर करें और इसका उपयोग करें। इस तरह, अगर पेड़ बदल जाता है और चलने का तरीका बदल जाता है, तो आपके पास चिंता करने के लिए केवल एक ही जगह होती है और बाकी सभी कोड "बस सही काम करते हैं।"
- यदि आप कागज के एक विशाल, समतल शीट पर अपने सभी रूटीन फैलाते हैं, तो उन्हें अन्य रूटीन के रूप में जोड़ने वाले तीरों के साथ, आप किसी भी एप्लिकेशन में देखेंगे कि रूटीन के "क्लस्टर" होंगे जिनमें बहुत सारे और बहुत सारे तीर हैं खुद के बीच लेकिन समूह के बाहर केवल कुछ तीर। इसलिए निकट युग्मित दिनचर्या के अन्य समूहों के बीच घनिष्ठ युग्मित दिनचर्या और शिथिल युग्मित संबंध की प्राकृतिक सीमाएं होंगी । अपने कोड को मॉड्यूल में व्यवस्थित करने के लिए इस तथ्य का उपयोग करें। यह आपके कोड की स्पष्ट जटिलता को काफी हद तक सीमित कर देगा।
उपरोक्त सभी कोडिंग के बारे में आम तौर पर सही है। मैंने मापदंडों, स्थानीय या स्थिर वैश्विक चर आदि के उपयोग पर चर्चा नहीं की। इसका कारण यह है कि एम्बेडेड प्रोग्रामिंग के लिए अनुप्रयोग स्थान अक्सर चरम और बहुत महत्वपूर्ण नए अवरोधों को रखता है और हर एम्बेडेड अनुप्रयोग पर चर्चा किए बिना उन सभी पर चर्चा करना असंभव है। और यहाँ वैसे भी नहीं हो रहा है।
ये बाधाएँ इनमें से कोई भी (और अधिक) हो सकती हैं:
- गंभीर लागत सीमाएँ जो न्यूनतम आदिम MCUs रैम और लगभग कोई I / O पिन-काउंट के साथ की आवश्यकता होती हैं। इनके लिए, नियमों के पूरे नए सेट लागू होते हैं। उदाहरण के लिए, आपको असेंबली कोड में लिखना पड़ सकता है क्योंकि बहुत अधिक कोड स्थान नहीं है। आपको केवल स्थैतिक चर का उपयोग करना पड़ सकता है क्योंकि स्थानीय चर का उपयोग बहुत महंगा और समय लेने वाला है। आपको सबरूटीन्स के अत्यधिक उपयोग से बचना पड़ सकता है क्योंकि (उदाहरण के लिए, कुछ माइक्रोचिप पीआईसी पार्ट्स) केवल 4 हार्डवेयर रजिस्टर हैं जिसमें सबरूटीन रिटर्न एड्रेस स्टोर करना है। तो आपको अपने कोड को नाटकीय रूप से "समतल" करना पड़ सकता है। आदि।
- गंभीर विद्युत सीमाएँ जिन्हें ध्यान से तैयार किए गए कोड की आवश्यकता होती है, पूर्ण गति से चलने पर MCU के अधिकांश भाग को बंद करने और कोड के निष्पादन समय पर गंभीर सीमाएँ बंद करने की आवश्यकता होती है। फिर, इसके लिए कुछ असेंबली कोडिंग की आवश्यकता हो सकती है।
- गंभीर समय की आवश्यकताएं। उदाहरण के लिए, ऐसे समय होते हैं जहाँ मुझे यह सुनिश्चित करना होता है कि एक ओपन-ड्रेन 0 के प्रसारण को ठीक उसी तरह से कई चक्रों में ले जाना पड़े जैसे कि 1. एक का संचरण इस समय के लिए एक सटीक रिश्तेदार चरण के साथ। इसका मतलब था कि C का यहाँ उपयोग नहीं किया जा सकता है। उस गारंटी को बनाने का एकमात्र संभव तरीका विधानसभा कोड को सावधानीपूर्वक बनाना है। (और फिर भी, हमेशा सभी ALU डिजाइनों पर नहीं।)
और इसी तरह। (लाइफ-क्रिटिकल मेडिकल इंस्ट्रूमेंटेशन के लिए वायरिंग कोड की अपनी पूरी दुनिया होती है, साथ ही।)
यहाँ पर मुख्य बात यह है कि एम्बेडेड कोडिंग अक्सर कुछ फ्री-फॉर-ऑल नहीं होती है, जहाँ आप कोड कर सकते हैं जैसे आप वर्कस्टेशन पर कर सकते हैं। अक्सर बहुत कठिन बाधाओं की एक विस्तृत विविधता के लिए गंभीर, प्रतिस्पर्धी कारण होते हैं। और ये अधिक पारंपरिक और स्टॉक उत्तरों के खिलाफ दृढ़ता से बहस कर सकते हैं ।
पठनीयता के बारे में, मुझे लगता है कि यह कोड पठनीय है यदि यह एक सुसंगत फैशन में लिखा गया है जो मैं इसे पढ़ सकता हूं। और जहां कोड को बाधित करने का जानबूझकर प्रयास नहीं किया गया है। वास्तव में बहुत अधिक आवश्यक नहीं है।
पठनीय कोड काफी कुशल हो सकता है और यह उपरोक्त सभी आवश्यकताओं को पूरा कर सकता है जो मैंने पहले ही उल्लेख किया है। मुख्य बात यह है कि आप पूरी तरह से समझते हैं कि आपके द्वारा लिखी गई कोड की प्रत्येक पंक्ति असेंबली या मशीन के स्तर पर क्या पैदा करती है। सी ++ प्रोग्रामर पर एक गंभीर बोझ डालता है क्योंकि कई परिस्थितियां हैं जहां सी ++ कोड के समान स्निपेट वास्तव में मशीन कोड के अलग-अलग स्निपेट उत्पन्न करते हैं जिनमें काफी अलग-अलग प्रदर्शन होते हैं। लेकिन सी, आम तौर पर, ज्यादातर एक "आप जो देखते हैं वह है जो आपको मिलता है" भाषा। तो यह उस संबंध में सुरक्षित है।
जेसन प्रति EDIT:
मैं 1978 से C का उपयोग कर रहा हूं और 1987 के बाद से C ++ और मुझे दोनों मेनफ्रेम, मिनीकंप्यूटर और (ज्यादातर) एम्बेडेड अनुप्रयोगों के लिए दोनों का उपयोग करने का बहुत अनुभव है।
जेसन एक संशोधक के रूप में 'इनलाइन' का उपयोग करने के बारे में एक टिप्पणी लाता है। (मेरे परिप्रेक्ष्य में, यह अपेक्षाकृत "नई" क्षमता है क्योंकि यह मेरे जीवन के शायद आधे या अधिक और C ++ का उपयोग करके मौजूद नहीं था।) इनलाइन फ़ंक्शन का उपयोग वास्तव में ऐसी कॉल कर सकता है (यहां तक कि एक पंक्ति के लिए भी। कोड) काफी व्यावहारिक है। और यह कहीं बेहतर है, जहां संभव है, टाइपिंग के कारण मैक्रो का उपयोग करने से, जो कंपाइलर लागू कर सकता है।
लेकिन सीमाएं हैं, साथ ही साथ। पहला यह है कि आप संकलक पर "संकेत लेने के लिए" भरोसा नहीं कर सकते। यह हो भी सकता है और नहीं भी। और संकेत न लेने के अच्छे कारण हैं। (एक स्पष्ट उदाहरण के लिए, यदि समारोह का पता लिया जाता है, इस की आवश्यकता समारोह के इन्स्टेन्शियशन और पते का उपयोग कॉल करने के लिए होगा ... एक फोन की आवश्यकता है। कोड तो inlined नहीं किया जा सकता।) कर रहे हैं अन्य कारणों से भी। कंपाइलरों में कई प्रकार के मानदंड हो सकते हैं जिसके द्वारा वे संकेत देते हैं कि कैसे संकेत को संभालना है। और एक प्रोग्रामर के रूप में, इसका मतलब आपको करना चाहिएसंकलक के उस पहलू के बारे में सीखने में कुछ समय बिताएं या फिर आप त्रुटिपूर्ण विचारों के आधार पर निर्णय लेने की संभावना रखते हैं। इसलिए यह कोड के लेखक और किसी भी पाठक दोनों के लिए एक बोझ जोड़ता है और किसी को भी कोड को किसी अन्य संकलक पर पोर्ट करने की योजना बना रहा है।
इसके अलावा, C और C ++ कंपाइलर अलग संकलन का समर्थन करते हैं। इसका मतलब है कि वे परियोजना के लिए किसी भी अन्य संबंधित कोड को संकलित किए बिना सी या सी ++ कोड का एक टुकड़ा संकलित कर सकते हैं। इनलाइन कोड के लिए, संकलक को संभालने से अन्यथा ऐसा करने का विकल्प चुन सकते हैं, इसके लिए न केवल घोषणा "स्कोप" होनी चाहिए, बल्कि इसकी परिभाषा भी होनी चाहिए, साथ ही। आमतौर पर, प्रोग्रामर यह सुनिश्चित करने के लिए काम करेंगे कि यह मामला है यदि वे 'इनलाइन' का उपयोग कर रहे हैं। लेकिन गलतियों को कम करना आसान है।
सामान्य तौर पर, जब मैं इनलाइन का उपयोग करता हूं, जहां मुझे लगता है कि यह उचित है, तो मुझे लगता है कि मैं इस पर भरोसा नहीं कर सकता हूं। यदि प्रदर्शन एक महत्वपूर्ण आवश्यकता है, और मुझे लगता है कि ओपी ने पहले ही स्पष्ट रूप से लिखा है कि एक महत्वपूर्ण प्रदर्शन हिट हो गया है जब वे अधिक "कार्यात्मक" मार्ग पर चले गए, तो मैं निश्चित रूप से कोडिंग अभ्यास के रूप में इनलाइन पर भरोसा करने से बचना चाहूंगा और इसके बजाय थोड़ा अलग, लेकिन कोड लिखने के पूरी तरह से सुसंगत पैटर्न का पालन कर सकते हैं।
एक अलग संकलन कदम के लिए 'इनलाइन' और परिभाषाओं के "दायरे में" होने के बारे में एक अंतिम नोट। लिंकिंग स्टेज पर किए जाने वाले कार्य के लिए यह (हमेशा विश्वसनीय नहीं) संभव है। ऐसा तब हो सकता है जब केवल C / C ++ कंपाइलर ऑब्जेक्ट फ़ाइलों में पर्याप्त विवरण को 'इनलाइन' अनुरोधों पर कार्य करने के लिए अनुमति देने के लिए पर्याप्त विवरण देता है। मैंने व्यक्तिगत रूप से एक लिंक सिस्टम (Microsoft के बाहर) का अनुभव नहीं किया है जो इस क्षमता का समर्थन करता है। लेकिन यह हो सकता है। फिर से, इस पर भरोसा किया जाना चाहिए या नहीं, यह परिस्थितियों पर निर्भर करेगा। लेकिन मैं आमतौर पर यह मानता हूं कि इसे लिंकर पर फावड़ा नहीं दिया गया है, जब तक कि मुझे नहीं पता कि अन्यथा अच्छे सबूत के आधार पर। और अगर मैं इस पर भरोसा करता हूं, तो इसे एक प्रमुख स्थान पर प्रलेखित किया जाएगा।
सी ++
उन लोगों के लिए, यहाँ इसका एक उदाहरण है कि मैं आज की तैयार उपलब्धता के बावजूद, एम्बेडेड अनुप्रयोगों को कोड करते समय C ++ से काफी सतर्क क्यों रहता हूं। मुझे लगता है कि मुझे लगता है कि सभी एम्बेडेड सी ++ प्रोग्रामर को ठंडा जानने के लिए कुछ शर्तों को टॉस करना होगा :
- आंशिक टेम्पलेट विशेषज्ञता
- vtables
- आभासी आधार वस्तु
- सक्रियण फ्रेम
- सक्रियण फ्रेम खोलना
- बिल्डरों में स्मार्ट पॉइंटर्स का उपयोग, और क्यों
- वापसी मूल्य अनुकूलन
यह सिर्फ एक छोटी सूची है। यदि आप पहले से ही उन शर्तों के बारे में सब कुछ नहीं जानते हैं और मैंने उन्हें क्यों सूचीबद्ध किया है (और कई और जिन्हें मैंने यहां सूचीबद्ध नहीं किया है) तो मैं एम्बेडेड कार्य के लिए C ++ के उपयोग के खिलाफ सलाह दूंगा, जब तक कि यह परियोजना का विकल्प नहीं है। ।
चलो बस एक स्वाद पाने के लिए C ++ अपवाद शब्दार्थ पर एक नज़र डालें।
C ++ कंपाइलर को कंपाइलिंग यूनिट के लिए सही कोड जनरेट करना होगा, जब यह पूरी तरह से पता नहीं है कि अलग-अलग और अलग-अलग समय पर संकलित किए गए अलग- अलग संकलन में किस तरह के अपवाद हैंडलिंग की आवश्यकता हो सकती है । बAB
कुछ संकलन इकाई में कुछ फ़ंक्शन के भाग के रूप में पाया गया कोड का यह क्रम लें :A
.
.
foo ();
String s;
foo ();
.
.
चर्चा के उद्देश्यों के लिए, संकलन इकाई अपने स्रोत में कहीं भी 'try..catch' का उपयोग नहीं करता है । न ही यह 'थ्रो' का उपयोग करता है। वास्तव में, मान लें कि यह किसी भी स्रोत का उपयोग नहीं करता है जिसे सी कंपाइलर द्वारा संकलित नहीं किया जा सकता है, इस तथ्य के अलावा कि यह सी ++ लाइब्रेरी समर्थन का उपयोग करता है और स्ट्रिंग जैसी वस्तुओं को संभाल सकता है। यह कोड सी स्रोत कोड फ़ाइल भी हो सकती है जिसे कुछ सी ++ सुविधाओं का लाभ लेने के लिए थोड़ा संशोधित किया गया था, जैसे स्ट्रिंग क्लास।A
इसके अलावा, मान लें कि फू () संकलन इकाई में स्थित एक बाहरी प्रक्रिया है और संकलक के पास इसके लिए एक घोषणा है, लेकिन इसकी परिभाषा नहीं जानता है।B
C ++ कंपाइलर foo () के लिए पहली कॉल देखता है और अगर कोई अपवाद फेंकता है, तो केवल एक सामान्य सक्रियण फ़्रेम को होने की अनुमति दे सकता है। दूसरे शब्दों में, C ++ कंपाइलर जानता है कि अपवाद हैंडलिंग में शामिल फ्रेम खोल प्रक्रिया का समर्थन करने के लिए इस बिंदु पर किसी अतिरिक्त कोड की आवश्यकता नहीं है।
लेकिन एक बार स्ट्रिंग के निर्माण के बाद, C ++ कंपाइलर जानता है कि फ्रेम ठीक होने से पहले इसे ठीक से नष्ट कर दिया जाना चाहिए, अगर बाद में कोई अपवाद होता है। तो फू को दूसरी कॉल () पहले से अलग शब्दार्थ है। अगर टू को फू () फेंकना अपवाद है (जो ऐसा कर सकता है या नहीं कर सकता है), तो सामान्य फ्रेम को होने देने से पहले स्ट्रिंगर के विनाश को संभालने के लिए संकलक को कोड डिजाइन करना चाहिए। यह फू () के लिए पहली कॉल के लिए आवश्यक कोड से अलग है।
( इस समस्या को सीमित करने में सहायता के लिए C ++ में अतिरिक्त सजावट जोड़ना संभव है। लेकिन तथ्य यह है कि, C ++ का उपयोग करने वाले प्रोग्रामर को कोड लिखने की प्रत्येक पंक्ति के निहितार्थों के बारे में अधिक जानकारी होनी चाहिए।)
C के मॉलोक के विपरीत, C ++ के नए अपवादों को संकेत करने के लिए उपयोग करता है जब यह कच्चे मेमोरी आवंटन नहीं कर सकता है। तो 'डायनामिक_कास्ट' होगा। (देखें स्ट्रॉस्ट्रुप का तीसरा संस्करण। C ++ प्रोग्रामिंग लैंग्वेज, पृष्ठ 384 और 385 C C ++ में मानक को छोड़कर।) कंपाइलर इस व्यवहार को अक्षम कर सकते हैं। लेकिन सामान्य तौर पर आप जनरेट किए गए कोड में प्रोलेग और एपिलॉग को ठीक से बनाए गए अपवाद के कारण कुछ ओवरहेड को उकसाएंगे, तब भी जब अपवाद वास्तव में जगह नहीं लेते हैं और तब भी जब फ़ंक्शन संकलित किया जा रहा है, वास्तव में कोई अपवाद हैंडलिंग ब्लॉक नहीं है। (स्ट्रॉस्ट्रुप ने सार्वजनिक रूप से इस पर अफसोस जताया है।)
आंशिक टेम्पलेट विशेषज्ञता के बिना (सभी C ++ कंपाइलर इसका समर्थन नहीं करते हैं), टेम्पलेट्स का उपयोग एम्बेडेड प्रोग्रामिंग के लिए आपदा जादू कर सकता है। इसके बिना, कोड ब्लूम एक गंभीर जोखिम है जो एक फ्लैश में एक छोटे-मेमोरी एम्बेडेड प्रोजेक्ट को मार सकता है।
जब C ++ फ़ंक्शन एक ऑब्जेक्ट लौटाता है तो एक अनाम संकलक अस्थायी बनाया जाता है और नष्ट हो जाता है। कुछ C ++ कंपाइलर कुशल कोड प्रदान कर सकते हैं यदि एक ऑब्जेक्ट कंस्ट्रक्टर का उपयोग स्थानीय वस्तु के बजाय रिटर्न स्टेटमेंट में किया जाता है, तो एक ऑब्जेक्ट द्वारा निर्माण और विनाश की जरूरतों को कम करना। लेकिन हर कंपाइलर ऐसा नहीं करता है और कई C ++ प्रोग्रामर को भी इस "रिटर्न वैल्यू ऑप्टिमाइज़ेशन" के बारे में पता नहीं होता है।
एक एकल पैरामीटर प्रकार के साथ एक ऑब्जेक्ट कंस्ट्रक्टर प्रदान करने से प्रोग्रामर को पूरी तरह से अनपेक्षित तरीके से दो प्रकारों के बीच रूपांतरण पथ खोजने के लिए C ++ कंपाइलर की अनुमति मिल सकती है। इस तरह का "स्मार्ट" व्यवहार सी का हिस्सा नहीं है।
एक बेस प्रकार निर्दिष्ट करने वाला कैच क्लॉज एक फेंकी गई वस्तु को "स्लाइस" करेगा, क्योंकि कैच किए गए ऑब्जेक्ट को कैच क्लॉज के "स्टैटिक टाइप" का उपयोग करके कॉपी किया जाता है न कि ऑब्जेक्ट के "डायनेमिक टाइप"। अपवाद दुख का एक असामान्य स्रोत नहीं है (जब आपको लगता है कि आप अपने एम्बेडेड कोड में अपवाद भी बर्दाश्त कर सकते हैं।)
C ++ कंपाइलर आपके लिए अनपेक्षित परिणामों के साथ स्वचालित रूप से आपके लिए कंस्ट्रक्टर, डिस्ट्रक्टर्स, कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर उत्पन्न कर सकते हैं। इसके विवरण के साथ सुविधा प्राप्त करने में समय लगता है।
बेस ऑब्जेक्ट की सरणियों को स्वीकार करने वाले फ़ंक्शन को व्युत्पन्न वस्तुओं के सरणियों को पास करना, शायद ही कभी चेतावनी चेतावनी उत्पन्न करता है लेकिन लगभग हमेशा गलत व्यवहार उत्पन्न करता है।
चूंकि C ++ आंशिक रूप से निर्मित वस्तुओं के विध्वंसक का आह्वान नहीं करता है जब ऑब्जेक्ट कंस्ट्रक्टर में कोई अपवाद होता है, तो कंस्ट्रक्टर में अपवादों को संभालने के लिए आमतौर पर "स्मार्ट पॉइंटर्स" को अनिवार्य किया जाता है ताकि यह सुनिश्चित किया जा सके कि यदि कोई अपवाद होता है, तो कंस्ट्रक्टर में निर्मित टुकड़े ठीक से नष्ट हो जाते हैं। । (देखें स्ट्रॉस्ट्रप, पृष्ठ 367 और 368।) सी ++ में अच्छी कक्षाएं लिखने में यह एक सामान्य मुद्दा है, लेकिन निश्चित रूप से सी में टाला गया क्योंकि सी में निर्माण और विनाश के शब्दार्थ नहीं हैं। निर्माण को संभालने के लिए उचित कोड लिखना। किसी वस्तु के भीतर उप-विषय का मतलब कोड लिखना जो C ++ में इस अनूठे शब्दार्थ मुद्दे से सामना करना चाहिए; दूसरे शब्दों में "सी + + अर्थ व्यवहार के आसपास लेखन"।
C ++ ऑब्जेक्ट्स को ऑब्जेक्ट पैरामीटर में पारित कर सकता है। उदाहरण के लिए, निम्नलिखित अंशों में, कॉल "आरए (एक्स);" C ++ कंपाइलर को पैरामीटर p के लिए एक कंस्ट्रक्टर को लागू करने के लिए कारण हो सकता है, तब ऑब्जेक्ट एक्स को पैरामीटर p में स्थानांतरित करने के लिए कॉपी कंस्ट्रक्टर को कॉल करें, फिर रिटर्न ऑब्जेक्ट के लिए एक अन्य कंस्ट्रक्टर (फ़ंक्शन का एक अनाम अस्थायी) rA, जो निश्चित रूप से पैरामीटर p से कॉपी किया गया। इससे भी बदतर, अगर क्लास ए की अपनी वस्तुएं हैं जिन्हें निर्माण की आवश्यकता है, तो यह आपदा को दूरबीन कर सकता है। (एसी प्रोग्रामर इस कचरे से सबसे अधिक बचेंगे, हाथ अनुकूलन के बाद से सी प्रोग्रामर के पास इतना आसान सिंटैक्स नहीं है और एक बार में सभी विवरणों को व्यक्त करना होगा।)
class A {...};
A rA (A p) { return p; }
// .....
{ A x; rA(x); }
अंत में, सी प्रोग्रामर के लिए एक छोटा नोट। longjmp () के पास C ++ में पोर्टेबल व्यवहार नहीं है। (कुछ C प्रोग्रामर इसे एक तरह के "अपवाद" तंत्र के रूप में उपयोग करते हैं।) कुछ C ++ कंपाइलर वास्तव में लॉन्गजंप लेने पर चीजों को साफ करने के लिए सेट करने का प्रयास करेंगे, लेकिन C ++ में वह व्यवहार पोर्टेबल नहीं है। यदि कंपाइलर निर्मित वस्तुओं को साफ करता है, तो यह गैर-पोर्टेबल है। यदि कंपाइलर उन्हें साफ नहीं करता है, तो ऑब्जेक्ट तबाह नहीं होते हैं जब कोड longjmp के परिणामस्वरूप कोड की गई वस्तुओं के दायरे को छोड़ देता है और व्यवहार अमान्य है। (अगर foo में longjmp का उपयोग) एक गुंजाइश नहीं छोड़ता है, तो व्यवहार ठीक हो सकता है।) यह अक्सर सी एम्बेडेड प्रोग्रामर द्वारा उपयोग नहीं किया जाता है, लेकिन उन्हें उपयोग करने से पहले इन मुद्दों से खुद को अवगत कराना चाहिए।