मैं सीखने की कोशिश कर रहा हूं कि डेटा को ठीक से कैसे भेजा जाए। वर्तमान में जिस तरह से मैं इसे करता हूं वह प्रत्येक आदेश के लिए एक नई सरणी बनाकर है।

unsigned char data0[]{ 0x00, 0x00 };
CommandSEND(handle, 0x01, 0x31, 0, 0, 2, data0);
CommandSEND(handle, 0x01, 0x31, 0, 0, 2, data0);
CommandSEND(handle, 0x01, 0x31, 0, 0, 2, data0);

unsigned char data1[]{ 0x01 };
CommandSEND(handle, 0x01, 0x31, 0, 0, 1, data1);

unsigned char data2[]{ 0x00,0x00 };
CommandSEND(handle, 0x01, 0x45, 0, 0, 2, data2);

// and so on... (i have data# variable going to data20)

मैं वैक्टर का उपयोग करने के बारे में सोच रहा था, लेकिन मैं जिस पुस्तकालय का उपयोग कर रहा हूं, वह केवल अहस्ताक्षरित चार सरणियों को स्वीकार करता है। इसके अलावा जब भी आप वेक्टर का आकार बदलते हैं, तो यह पिछली मेमोरी को हटा देता है और इसे एक नए स्थान पर कॉपी कर देता है (जो मुझे लगता है कि पर्दे के पीछे हो रहा है)। जो मुझे लगता है कि मेरे कई चर होने से अलग नहीं है।

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

मुझे उम्मीद है कि मेरा कोड जितना जल्दी हो सके चलाने के लिए है, इसलिए मुझे ऐसा लगता है कि अगर मैं इसे हटाना और असाइन करना जारी रखता हूं तो इसमें समय लगेगा और इसे करने का एक बेहतर, अधिक अनुकूलित तरीका हो सकता है।

मैं अपने कोड को अच्छी तरह से अनुकूलित रखने में सक्षम होना सीखना चाहता हूं।

धन्यवाद, किसी भी सुझाव और आलोचना का स्वागत है। यह भी सुनिश्चित नहीं था कि इस प्रश्न के लिए सबसे अच्छा शीर्षक क्या होगा।

0
aapp 21 नवम्बर 2018, 02:56

1 उत्तर

सबसे बढ़िया उत्तर

यह मानते हुए कि आपका कोड खंड किसी फ़ंक्शन के अंदर है, आप पहले से ही जितनी जल्दी हो सके चीजें कर रहे हैं। आपके unsigned char सरणी चर data0, data1 और data2 स्वचालित हैं, जिसका अर्थ है कि वे प्रवेश पर स्टैक पॉइंटर को समायोजित करके "आवंटित" (और "मुक्त") कर रहे हैं (और से बाहर निकलें) समारोह - कोई ढेर कार्रवाई नहीं हो रही है।

चूंकि सरणियों में प्रारंभकर्ता होते हैं, इसलिए संकलक ने सरणी की प्रारंभिक सामग्री को कहीं स्थिर स्मृति में संग्रहीत करने की व्यवस्था की होगी, और फ़ंक्शन में प्रवेश पर, उन प्रारंभकर्ताओं को स्टैक पर उपयुक्त क्षेत्रों में कॉपी किया जाता है जहां स्वचालित चर रहते हैं। यह कॉपी ही एकमात्र ऐसी चीज है जिसे आप संभवतः अनुकूलित कर सकते हैं (किसी तरह), लेकिन मैं यह नहीं देखता कि आप इसे कैसे करेंगे जब तक कि CommandSEND का अंतिम तर्क एक const unsigned char * न हो। अगर CommandSEND उस तर्क को संशोधित करता है, तो आपको हर बार फ़ंक्शन में प्रवेश करने पर सरणियों को फिर से शुरू करना होगा।

वास्तव में, हालांकि आपकी टिप्पणी कहती है कि CommandSEND अपने अंतिम तर्क को संशोधित करता है, आप इसे data0 को फिर से शुरू किए बिना पहले श्लोक में तीन बार कॉल कर रहे हैं। तो या तो आप उन तीन CommandSEND कॉलों में तीन (संभवतः) अलग-अलग कमांड भेजने का इरादा रखते हैं, या CommandSEND वास्तव में अपना अंतिम तर्क नहीं बदलते हैं। शायद लाइब्रेरी (और इसकी हेडर फाइल) को बेहतर constनेस गारंटी देने के लिए इसके फंक्शन प्रोटोटाइप पर सुधार किया जाना चाहिए। यह एक उदाहरण है जहां यह महत्वपूर्ण हो सकता है - यदि पुस्तकालय वादा कर सकता है कि CommandSEND का अंतिम तर्क const था, तो आप तर्क के रूप में static const unsigned char[] data0 पास कर सकते हैं। यह प्रारंभिक प्रतिलिपि को समाप्त कर देगा, और यदि कोई अन्य स्वचालित चर नहीं हैं, तो यह संभव है कि फ़ंक्शन प्रविष्टि और निकास थोड़ा तेज़ हो। यदि आपके द्वारा भेजे गए सभी आदेश केवल कुछ बाइट लंबे हैं, तो आप उन्हें (const unsigned char *)"\x12\x34\x56\x78" के रूप में भी लिख सकते हैं। या, स्पष्ट अभिव्यक्ति और बेहतर रखरखाव के लिए, आप आदेशों के लिए स्थिरांक या प्रीप्रोसेसर मैक्रोज़ को परिभाषित कर सकते हैं, और फिर कह सकते हैं:

CommandSEND( handle, 0x01, 0x31, 0, 0, 2, FIRST_COMMAND );
CommandSEND( handle, 0x01, 0x31, 0, 0, 2, SECOND_COMMAND );
CommandSEND( handle, 0x01, 0x31, 0, 0, 2, THIRD_COMMAND );

कुल मिलाकर, मुझे नहीं लगता कि आपके प्रोग्राम के इस हिस्से में कोड-आकार या निष्पादन-गति अनुकूलन के लिए बहुत अधिक अवसर हैं। पढ़ने या समझने में आसान बनाने के लिए आप निश्चित रूप से कुछ मानव-निर्देशित अनुकूलन कर सकते हैं, लेकिन संकलक को इसे तेज़ी से चलाने में मदद करने के लिए आप और कुछ नहीं कर सकते हैं। (और आपको तब तक ऐसा करने की कोशिश नहीं करनी चाहिए जब तक कि आपने कोड को प्रोफाइल नहीं किया है और यह निर्धारित किया है कि यह वास्तव में आपकी गति बाधा है - समयपूर्व अनुकूलन सभी बुराइयों का वर्गमूल है!)

1
Dave M. 21 नवम्बर 2018, 03:43