boost::array (या tr1 या std संस्करण) अंतर्निहित सरणी पर कुछ अच्छी अतिरिक्त सुविधाएं प्रदान करते हैं।क्या एक अंतर्निहित सरणी को std/tr1/boost :: array के साथ प्रतिस्थापित करना हमेशा सुरक्षित है?
अब तक, हमारे codebase केवल शामिल निर्मित सरणियों, उदाहरण के के लिए (थे, लेकिन शैली से मेल खाता):
WORD m_lastReadFlags[FLAGS_MAX];
...
WORD flagBuffer[FLAGS_MAX];
if (getFlags(flagBuffer)) {
memcpy(m_lastReadFlags, flagBuffer, sizeof(m_lastReadFlags));
...
मुझे लगता है कि one'll विचार मिलता है।
अब, मेरा प्रश्न है, कोड में उन स्थानों के लिए, जहां boost::array में ड्रॉप करना समझ में आता है (अन्य परिवर्तनों के कारण), array निर्मित 100% अर्थशास्त्र में अंतर्निहित सरणी के लिए ड्रॉप-इन संरक्षित है? (संभावित संकलक त्रुटियों ठीक कर रहे हैं - केवल मूक व्यवहार में परिवर्तन क्या मुझे परेशान कर रहा है कर रहे हैं।)
है, कोड ऊपर फिर से लिखा जा सकता है (उदाहरण के लिए) का उपयोग करने के लिए:
boost::array<WORD, FLAGS_MAX> m_lastReadFlags;
और memcpy (संभवतः c_array() या data() का उपयोग करने के लिए अनुकूलित) और अन्य सरणी जैसी पहुंच वही रहेगी? हां, ज़ाहिर है कि मैं स्थानीय बफर को एक सरणी से भी बदल सकता हूं और memcpy को हटा सकता हूं या std::copy या ऐसा कुछ उपयोग कर सकता हूं, लेकिन इस प्रश्न का बिंदु अंतर्निर्मित सरणी और सरणी वर्ग की संगतता के बारे में है।
अद्यतन: एक बात है कि मुझे विशेष रूप से परेशान कर स्थानों (memcpy मामले में) की तरह है, जहां में निर्मित सरणियों संकेत के रूप में इस्तेमाल कर रहे हैं। क्या सभी अवसर संकलक/सही तरीके से संभाले जाएंगे?
असाइनमेंट के बारे में क्या?
T arr1[N]; // or array<T, N>
T arr2[N]; // or array<T, N>
T* p1;
...
// Note, not all combinations will compile:
arr1 = arr2;
p1 = arr1;
arr2 = p1;
...