सी में मॉड्यूलर फर्मवेयर डिजाइन के लिए स्मृति आवंटित करने के लिए संभावनाएं

Question

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

अभी, मैं सोच रहा हूं कि मॉड्यूल का वर्णन करने वाली संरचना के लिए आवंटन मेमोरी का सबसे अच्छा तरीका क्या हो सकता है। यदि संभव हो, तो मैं निम्नलिखित चाहूंगा:

• अपारदर्शी संरचना, इसलिए संरचना केवल प्रदान किए गए इंटरफ़ेस फ़ंक्शंस के उपयोग से बदल सकती है
• कई उदाहरण हैं
• लिंकर द्वारा आवंटित स्मृति

मैं निम्नलिखित संभावनाओं को देखता हूं, कि मेरे एक लक्ष्य के साथ सभी संघर्ष:

वैश्विक घोषणा

कई उदाहरण, लिंकर द्वारा आवंटित, लेकिन संरचना अपारदर्शी नहीं है

(#includes)
module_struct module;

void main(){
   module_init(&module);
}

malloc

अपारदर्शी संरचना, कई उदाहरण, लेकिन ढेर पर आवंटन

मॉड्यूल में:

typedef module_struct Module;

मॉड्यूल। init फ़ंक्शन, आवंटित स्मृति में मॉलोक और रिटर्न पॉइंटर

module_mem = malloc(sizeof(module_struct ));
/* initialize values here */
return module_mem;

में मुख्य

(#includes)
Module *module;

void main(){
    module = module_init();
}

मॉड्यूल में घोषणा

अपारदर्शी संरचना, लिंकर द्वारा आवंटित, केवल एक पूर्वनिर्धारित संख्या के उदाहरण

मॉड्यूल के लिए पूरी संरचना और मेमोरी को आंतरिक रखें और हैंडलर या संरचना को कभी उजागर न करें।

(#includes)

void main(){
    module_init(_no_param_or_index_if_multiple_instances_possible_);
}

---

क्या अपारदर्शी संरचना, लिंकर के बजाय ढेर आवंटन और कई / किसी भी उदाहरण के लिए किसी भी तरह से संयोजन करने का विकल्प है?

समाधान

जैसा कि नीचे कुछ उत्तरों में प्रस्तावित है, मुझे लगता है कि सबसे अच्छा तरीका यह है:

1. मॉड्यूल स्रोत फ़ाइल में MODULE_MAX_INSTANCE_COUNT मॉड्यूल के लिए आरक्षित स्थान
2. मॉड्यूल में MODULE_MAX_INSTANCE_COUNT को परिभाषित न करें
3. मॉड्यूल हेडर फ़ाइल के लिए #ifndef MODULE_MAX_INSTANCE_COUNT #error जोड़ें यह सुनिश्चित करने के लिए कि मॉड्यूल उपयोगकर्ता इस सीमा से अवगत है और आवेदन के लिए वांछित उदाहरणों की अधिकतम संख्या को परिभाषित करता है।
4. इंस्टेंस के आरंभीकरण पर या तो डेस्क्रिकिव स्ट्रक्चर या मॉड्यूल इंडेक्स (जो भी अधिक पसंद हो) का मेमोरी एड्रेस (* शून्य) वापस कर दें

Comments

अधिकांश एम्बेडेड एफडब्ल्यू डिज़ाइनर स्मृति उपयोग निर्धारक और सरल रखने के लिए गतिशील आवंटन से बच रहे हैं। खासकर अगर यह नंगे-धातु है और स्मृति का प्रबंधन करने के लिए अंतर्निहित ओएस नहीं है।

— यूजीन श।

वास्तव में, यही कारण है कि मैं लिंकर को आवंटन करना चाहता हूं।

— एल। हेनरिकस

मुझे पूरा यकीन नहीं है कि मैं समझ पा रहा हूँ ... यदि आपके पास इंस्टेंस की एक डायनामिक संख्या है, तो आपको लिंकर द्वारा आवंटित मेमोरी कैसे मिल सकती है? यह मुझे काफी ओर्थोगोनल लगता है।

— जकरॉन

क्यों नहीं लिंकर को एक बड़ा मेमोरी पूल आवंटित करने दें, और उससे अपना खुद का आवंटन करें, जो आपको शून्य-ओवरहेड एलोकेटर का लाभ भी देता है। आप फ़ाइल को आवंटन फ़ंक्शन के साथ पूल ऑब्जेक्ट को स्थिर बना सकते हैं, इसलिए यह निजी है। मेरे कुछ कोड में, मैं विभिन्न init दिनचर्या में सभी आवंटन करता हूं, फिर मैं बाद में प्रिंट करता हूं कि कितना आवंटित किया गया था, इसलिए अंतिम उत्पादन संकलन में मैंने पूल को उस सटीक आकार में सेट किया।

— ली डैनियल क्रोकर

यदि यह संकलन-समय का निर्णय है, तो आप बस अपने Makefile या समकक्ष में संख्या को परिभाषित कर सकते हैं, और आप सभी सेट कर सकते हैं। मॉड्यूल के स्रोत में संख्या नहीं होगी, लेकिन आवेदन विशिष्ट होगा, और आप बस एक पैरामीटर के रूप में एक आवृत्ति संख्या का उपयोग करते हैं।

— जकारॉन

Answer 1

क्या कोई विकल्प है कि वे किसी भी तरह से गुमनाम संरचना, लिंकर के बजाय ढेर आवंटन और कई / किसी भी उदाहरण के लिए जोड़ सकते हैं?

जरूर है। सबसे पहले, हालांकि, मान्यता है कि उदाहरणों के "किसी भी संख्या" को निश्चित समय पर, या कम से कम एक ऊपरी बाध्य स्थापित होना चाहिए। यह उदाहरणों के लिए एक पूर्वापेक्षा है कि इसे सांख्यिकीय रूप से आवंटित किया जाए (जिसे आप "लिंकर आवंटन" कह रहे हैं)। आप मैक्रो की घोषणा करके स्रोत संशोधन के बिना संख्या को समायोज्य बना सकते हैं।

फिर वास्तविक संरचना घोषणा और उसके सभी संबंधित कार्यों से युक्त स्रोत फ़ाइल भी आंतरिक लिंकेज के साथ उदाहरणों की एक सरणी घोषित करती है। यह या तो एक सरणी प्रदान करता है, बाहरी लिंकेज के साथ, उदाहरणों को इंगित करता है या सूचकांक द्वारा विभिन्न बिंदुओं तक पहुंचने के लिए एक फ़ंक्शन होता है। फ़ंक्शन भिन्नता थोड़ी अधिक मॉड्यूलर है:

module.c

#include <module.h>

// 4 instances by default; can be overridden at compile time
#ifndef NUM_MODULE_INSTANCES
#define NUM_MODULE_INSTANCES 4
#endif

struct module {
    int demo;
};

// has internal linkage, so is not directly visible from other files:
static struct module instances[NUM_MODULE_INSTANCES];

// module functions

struct module *module_init(unsigned index) {
    instances[index].demo = 42;
    return &instances[index];
}

मुझे लगता है कि आप पहले से ही परिचित हैं कि हेडर कैसे संरचना को अपूर्ण प्रकार के रूप में घोषित करेगा और सभी कार्यों की घोषणा करेगा ( उस प्रकार के संकेत के रूप में लिखा गया है )। उदाहरण के लिए:

module.h

#ifndef MODULE_H
#define MODULE_H

struct module;

struct module *module_init(unsigned index);

// other functions ...

#endif

अब struct moduleअनुवाद इकाइयों के अलावा अपारदर्शी है module.c, ^* और आप किसी भी गतिशील आवंटन के बिना संकलन समय पर परिभाषित उदाहरणों की संख्या तक पहुंच और उपयोग कर सकते हैं।

---

^* जब तक आप इसकी परिभाषा की नकल न करें, तब तक। मुद्दा यह है कि module.hऐसा नहीं है।

Comments

मुझे लगता है कि यह कक्षा के बाहर से सूचकांक को पारित करने के लिए एक अजीब डिजाइन है। जब मैं मेमोरी पूल को इस तरह लागू करता हूं, तो मैं इंडेक्स को एक निजी काउंटर होने देता हूं, जो हर आवंटित उदाहरण के लिए 1 से बढ़ रहा है। जब तक आप "NUM_MODULE_INSTANCES" तक नहीं पहुंचेंगे, जहां कंस्ट्रक्टर मेमोरी त्रुटि से बाहर आ जाएगा।

— लुंडिन

यह एक उचित बिंदु है, @ लुंडिन। डिजाइन का वह पहलू यह बताता है कि अनुक्रमणिका में अंतर्निहित महत्व है, जो वास्तव में हो सकता है या नहीं। यह है ओ पी के शुरू करने के मामले के लिए मामला है, यद्यपि तुच्छता हां, तो। इस तरह के महत्व, यदि यह मौजूद है, तो बिना किसी उदाहरण के सूचक को आरंभ किए बिना प्राप्त करने के लिए साधन प्रदान करके आगे समर्थन किया जा सकता है ।

— जॉन बोलिंगर

तो मूल रूप से आप n मॉड्यूल के लिए मेमोरी आरक्षित करते हैं, चाहे कितने भी उपयोग किए जाएं, फिर एक अप्रयुक्त तत्व को अगले अप्रयुक्त तत्व पर लौटाएं यदि एप्लिकेशन इसे आरंभीकृत करता है। मुझे लगता है कि काम कर सकता है।

— एल। हेनरिक्स

@ एल। हाइनरिक्स हां, क्योंकि एम्बेडेड सिस्टम एक नियतात्मक प्रकृति के हैं। "वस्तुओं की अंतहीन मात्रा" या "अज्ञात वस्तुओं की मात्रा" जैसी कोई चीज नहीं है। ऑब्जेक्ट अक्सर एकल (हार्डवेयर ड्राइवर) भी होते हैं, इसलिए अक्सर मेमोरी पूल की कोई आवश्यकता नहीं होती है, क्योंकि ऑब्जेक्ट का सिर्फ एक ही उदाहरण मौजूद होगा।

— लुंडिन

मैं ज्यादातर मामलों के लिए सहमत हूं। इस सवाल का कुछ सैद्धांतिक हित भी था। लेकिन मैं सैकड़ों 1-तार तापमान सेंसर का उपयोग कर सकता हूं यदि पर्याप्त आईओएस उपलब्ध हैं (जैसा कि एक उदाहरण मैं अब तक आ सकता हूं)।

— एल। हेनरिक

Answer 2

मैं C ++ में छोटे माइक्रो-कंट्रोलर प्रोग्राम करता हूं, जो वास्तव में आपको चाहिए।

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

क्लास ऑब्जेक्ट वैश्विक हो सकता है (इसलिए आप लिंक-टाइम पर जानते हैं कि सब कुछ फिट होगा), या मुख्य रूप से स्टैक-लोकल। (अपरिभाषित वैश्विक आरंभिक क्रम के कारण मुझे C ++ ग्लोबल्स पसंद नहीं है, इसलिए मैं स्टैक-लोकल पसंद करता हूं)।

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

C ++ में कोडिंग के इस तरीके पर मेरी बात: ऑब्जेक्ट? जी नहीं, धन्यवाद!

एम्बेडेड / माइक्रोकंट्रोलर प्रोग्रामर का एक बहुत सी ++ नापसंद करने के लिए क्योंकि उन्हें लगता है इसका इस्तेमाल करने के लिए उन्हें मजबूर होना पड़ा लग रहे सभी सी ++ की। यह पूरी तरह से नहीं है, और बहुत बुरा विचार होगा। (आप शायद सी के सभी का उपयोग नहीं करते! थिंक हीप, फ्लोटिंग पॉइंट, सेटजम्प / लॉन्गजम्प, प्रिंटफ, ...)

---

एक टिप्पणी में एडम हाउ ने RAII और आरंभीकरण का उल्लेख किया है। IMO RAII को डिकंस्ट्रक्शन के साथ अधिक करना है, लेकिन उसकी बात वैध है: वैश्विक वस्तुओं का निर्माण आपके मुख्य शुरू होने से पहले किया जाएगा, इसलिए वे अमान्य मान्यताओं पर काम कर सकते हैं (जैसे एक मुख्य घड़ी की गति जिसे बाद में बदल दिया जाएगा)। यह एक और कारण है कि वैश्विक कोड-इनिशियलाइज्ड वस्तुओं का उपयोग नहीं करना है। (मैं एक लिंकर स्क्रिप्ट का उपयोग करता हूं जो वैश्विक कोड-आरंभिक वस्तुओं के होने पर विफल हो जाएगा।) IMO ऐसी 'वस्तुएं' स्पष्ट रूप से बनाई और पास होनी चाहिए। इसमें एक 'प्रतीक्षा' सुविधा 'ऑब्जेक्ट' शामिल है जो एक प्रतीक्षा () फ़ंक्शन प्रदान करता है। मेरे सेटअप में यह 'ऑब्जेक्ट' है जो चिप की घड़ी की गति निर्धारित करता है।

RAII के बारे में बात करना: यह एक और C ++ फीचर है जो छोटे एम्बेडेड सिस्टम में बहुत उपयोगी है, हालांकि इस कारण (मेमोरी डीक्लोकेशन) के लिए नहीं इसका उपयोग लार्गेरे सिस्टम में किया जाता है (छोटे एम्बेडेड सिस्टम ज्यादातर डायनामिक मेमोरी डीक्लोकेशन का उपयोग नहीं करते हैं)। किसी संसाधन को लॉक करने के बारे में सोचें: आप लॉक किए गए संसाधन को एक रैपर ऑब्जेक्ट बना सकते हैं, और केवल लॉकिंग रैपर के माध्यम से संसाधन तक पहुंच को प्रतिबंधित कर सकते हैं। जब आवरण दायरे से बाहर हो जाता है, तो संसाधन अनलॉक हो जाता है। यह बिना लॉक किए एक्सेस को रोकता है, और अनलॉकिंग को भूलने की संभावना को और अधिक बढ़ा देता है। कुछ (टेम्पलेट) जादू के साथ यह शून्य-ओवरहेड हो सकता है।

---

मूल प्रश्न में C का उल्लेख नहीं है, इसलिए मेरा C ++ - केंद्रित उत्तर है। यदि यह वास्तव में सी होना चाहिए ...।

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

या आपकी संरचना का एक सार्वजनिक संस्करण है, जिसमें कुछ भी उपयोगी नहीं है, और आपके .c फ़ाइल में निजी संस्करण (उपयोगी डेटा के साथ) है, और यह दावा करते हैं कि वे समान आकार के हैं। थोड़ा-सा मेक-फ़्लो टोने-टोटका इसे स्वचालित कर सकता था।

---

@Lundins खराब (एम्बेडेड) प्रोग्रामर के बारे में टिप्पणी करते हैं:

• आपके द्वारा वर्णित प्रोग्रामर का प्रकार संभवतः किसी भी भाषा में गड़बड़ी करेगा। मैक्रो (सी और सी ++ में मौजूद) एक स्पष्ट तरीका है।

• टूलींग कुछ हद तक मदद कर सकता है। अपने छात्रों के लिए मैं एक निर्मित स्क्रिप्ट को अनिवार्य करता हूं जो बिना किसी अपवाद, नो-आरटीआई को निर्दिष्ट करता है, और एक लिंकर त्रुटि देता है जब या तो ढेर का उपयोग किया जाता है या कोड-आरंभिक ग्लोबल्स मौजूद होते हैं। और यह चेतावनी = त्रुटि को निर्दिष्ट करता है और लगभग सभी चेतावनियों को सक्षम करता है।

• मैं टेम्प्लेट का उपयोग करने के लिए प्रोत्साहित करता हूं, लेकिन कॉन्स्टैक्स और अवधारणाओं के साथ मेटाप्रोग्रामिंग कम और कम आवश्यक है।

• "भ्रमित Arduino प्रोग्रामर" मैं एक आधुनिक C ++ दृष्टिकोण के साथ Arduino (तारों, पुस्तकालयों में कोड की प्रतिकृति) प्रोग्रामिंग शैली को बदलना बहुत पसंद करूंगा, जो कि आसान, अधिक सुरक्षित और तेजी से और छोटे कोड का उत्पादन कर सकता है। अगर केवल मेरे पास समय और शक्ति होती…।

Comments

इस उत्तर के लिए धन्यवाद! C ++ का उपयोग करना एक विकल्प है, लेकिन हम अपनी कंपनी में C का उपयोग कर रहे हैं (जो मैंने स्पष्ट रूप से उल्लेख किया है)। मैं सवाल करने देने के लिए अद्यतन किया है लोगों को पता है मैं सी के बारे में बात

— एल Heinrichs

आप (केवल) C का उपयोग क्यों कर रहे हैं? हो सकता है कि यह आपको उन्हें कम से कम C ++ पर विचार करने का मौका दे ... आप जो चाहते हैं वह जरूरी है (C का एक छोटा सा हिस्सा) C में एहसास हुआ

— Wouter van Ooijen

मैं अपने (पहले 'वास्तविक' एम्बेडेड हॉबी प्रोजेक्ट) में क्या करता हूं, कंस्ट्रक्टर में सरल डिफ़ॉल्ट को इनिशियलाइज़ कर रहा है, और संबंधित कक्षाओं के लिए एक अलग इनिट विधि का उपयोग करता है। एक और लाभ यह है कि मैं यूनिट परीक्षण के लिए स्टब पॉइंटर्स पास कर सकता हूं।

— मिशेल किजर्स

@ एक शौक परियोजना के लिए आप भाषा चुनने के लिए स्वतंत्र हैं? C ++ ले लो!

— राउटर वैन ओइजेन

और जबकि यह वास्तव में एम्बेडेड के लिए अच्छा सी ++ प्रोग्राम लिखना पूरी तरह से संभव है, समस्या यह है कि कुछ> सभी एम्बेडेड सिस्टम प्रोग्रामर में से 50% क्वैक्स हैं, पीसी प्रोग्रामर, अरड्यूनो हॉबीस्ट आदि आदि इस तरह के लोग बस का उपयोग नहीं कर सकते हैं। C ++ का सबसे अच्छा निर्वाह, भले ही आप इसे उनके चेहरे पर समझाएं। उन्हें C ++ दें और इससे पहले कि आप यह जानते हैं, वे संपूर्ण STL, टेम्पलेट मेटाप्रोग्रामिंग, अपवाद हैंडलिंग, एकाधिक वंशानुक्रम आदि का उपयोग करेंगे। और परिणाम पूरी तरह से कचरा है। यह, दुख की बात है कि 10 में से 8 एम्बेडेड सी ++ प्रोजेक्ट्स में से 8 कैसे समाप्त होते हैं।

— लुंडिन

Answer 3

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

Comments

अच्छा विचार है, मुझे लगता है कि मैं इस्तेमाल कर सकता है --- #define BUILD_BUG_ON (स्थिति) ((शून्य) आकार (चार [1 - 2 * !! (शर्त)))) --- BUILD_BUG_ON (sizeof (real_struct) = = sizeof (! fake_struct)) ----

— एल। हेनरिक

Answer 4

अनाम संरचना, इसलिए संरचना केवल प्रदान की गई इंटरफ़ेस फ़ंक्शंस के उपयोग से बदल सकती है

मेरी राय में, यह व्यर्थ है। आप वहां एक टिप्पणी डाल सकते हैं, लेकिन कोई भी बिंदु इसे छिपाने की कोशिश नहीं कर रहा है।

सी कभी भी इस तरह के उच्च अलगाव प्रदान नहीं करेगा, भले ही संरचना के लिए कोई घोषणा न हो, गलती से इसे गलत तरीके से अधिलेखित करना आसान होगा जैसे कि गलत मेम्कपी () या बफर ओवरफ्लो।

इसके बजाय, बस संरचना को एक नाम दें और अच्छे कोड लिखने के लिए अन्य लोगों पर भरोसा करें। यह डीबग करना भी आसान बना देगा जब संरचना में एक नाम होता है जिसे आप इसे संदर्भित करने के लिए उपयोग कर सकते हैं।

Answer 5

शुद्ध SW सवाल /programming/ पर बेहतर पूछे जाते हैं ।

कॉल करने के लिए अपूर्ण प्रकार की संरचना को उजागर करने के साथ अवधारणा , जैसे आप वर्णन करते हैं, अक्सर "अपारदर्शी प्रकार" या "अपारदर्शी बिंदु" कहा जाता है - अनाम संरचना का अर्थ पूरी तरह से कुछ और है।

इसके साथ समस्या यह है कि कॉलर ऑब्जेक्ट के उदाहरणों को आवंटित करने में सक्षम नहीं होगा, केवल इसे इंगित करता है। एक पीसी पर आप mallocऑब्जेक्ट्स "कंस्ट्रक्टर" के अंदर उपयोग करेंगे , लेकिन मॉलोक एम्बेडेड सिस्टम में एक नो-गो है।

तो जो आप एम्बेडेड में करते हैं वह एक मेमोरी पूल प्रदान करना है। आपके पास सीमित मात्रा में RAM है, इसलिए बनाई जाने वाली वस्तुओं की संख्या को सीमित करना आमतौर पर कोई समस्या नहीं है।

एसओ पर अपारदर्शी डेटा प्रकारों का स्थैतिक आवंटन देखें ।

Comments

कहां मेरे अंत पर नामकरण भ्रम स्पष्ट करने के लिए धन्यवाद, बीमार ओपी समायोजित करें। मैं अतिप्रवाह के ढेर में जाने के बारे में सोच रहा था, लेकिन तय किया कि मैं विशेष रूप से एम्बेडेड प्रोग्रामर को लक्षित करना चाहूंगा।

— एल। हेनरिक्स