मैं संरचना क्षेत्रों को गतिशील रूप से कैसे एक्सेस करूं?

Question

मेरे पास कई क्षेत्रों के साथ एक संरचना है जो विभिन्न लंबाई के वैक्टर हैं। मैं क्रमशः लूप के भीतर फ़ील्ड तक पहुंच बनाना चाहता हूं। मैंने गेटफील्ड को निम्नानुसार करने की कोशिश की लेकिन MATLAB को यह पसंद नहीं आया। मैं यह कैसे कर सकता हूँ?

S = struct('A', [1 2], 'B',[3 4 5]); 
SNames = fieldnames(S); 
for loopIndex = 1:2 
    field = getfield(S, SNames(loopIndex)); 
    %do stuff w/ field 
end 
??? Index exceeds matrix dimensions 

मैं पहले स्थान पर संरचनाओं का उपयोग कर रहा हूं क्योंकि एक सरणी को विभिन्न फ़ील्ड लंबाई के साथ परेशानी होगी। क्या इसके लिए कोई बेहतर विकल्प है?

Answer 1

डायनामिक फ़ील्ड संदर्भ का प्रयास करें जहां आप सामग्री परिभाषित लाइन पर देखे गए ब्रांड्स में स्ट्रिंग डालते हैं।

S = struct('A', [1 2], 'B',[3 4 5]); 
SNames = fieldnames(S); 
for loopIndex = 1:numel(SNames) 
    stuff = S.(SNames{loopIndex}) 
end 

मैं स्टीव और एडम के साथ सहमत हूं। कोशिकाओं का प्रयोग करें। हालांकि यह वाक्यविन्यास अन्य स्थितियों में लोगों के लिए सही है!

Answer 2

गेटफील्ड दृष्टिकोण ठीक है (हालांकि मेरे पास अभी MATLAB उपलब्ध नहीं है और यह मुझे स्पष्ट नहीं है कि उपर्युक्त क्यों काम नहीं करेगा)।

वैकल्पिक डेटा संरचना के लिए, आप MATLAB सेल सरणी भी देखना चाहेंगे। वे आपको अलग-अलग लंबाई के वैक्टरों को स्टोर और इंडेक्स करने की अनुमति भी देंगे।

Answer 3

तीन अंक मैं यहाँ करना चाहते हैं कर रहे हैं:

• कारण आप अपने ऊपर कोड में कोई त्रुटि हो रही है क्योंकि तुम कैसे SNames का अनुक्रमण कर रहे हैं की है। फ़ंक्शन fieldnames तारों के cell array लौटाता है, इसलिए आपको स्ट्रिंग मानों तक पहुंचने के लिए content indexing (यानी घुंघराले ब्रेसिज़) का उपयोग करना होगा। यदि आप अपने कोड में चौथी पंक्ति को इस पर बदलते हैं:

  field = getfield(S, SNames{loopIndex}); 
  

  तो आपके कोड को बिना किसी त्रुटि के काम करना चाहिए।

• MatlabDoug ने सुझाव दिया रूप में, आप dynamic field names का उपयोग (जो क्लीनर कोड देख पैदावार, मेरी राय में) getfield उपयोग करने के लिए होने से बचने कर सकते हैं।

• suggestion from Adam संरचना के बजाय cell array का उपयोग करने के लिए चिह्न पर सही है। यह आमतौर पर एक एकल चर में विभिन्न लंबाई के सरणी की एक श्रृंखला एकत्र करने का सबसे अच्छा तरीका है। आपका कोड खत्म होगा कुछ इस तरह की तलाश में:

  S = {[1 2], [3 4 5]};  % Create the cell array 
  for loopIndex = 1:numel(S) % Loop over the number of cells 
      array = S{loopIndex};  % Access the contents of each cell 
      % Do stuff with array 
  end 
  

Answer 4

आप पेट के संकेतन का उपयोग अनुक्रमित से बचने के लिए कर सकते हैं:

S = struct('A', [1 2], 'B',[3 4 5]); 
SNames = fieldnames(S); 
for SName = [SNames{:}] 
    stuff = S.(SName) 
end 

Answer 5

आप एक संरचना है कि मैं क्या पाया बहुत अच्छी तरह से काम किया था का उपयोग करने की जरूरत है पहले सेल में कनवर्ट करने के लिए आपके पास दोनों दुनिया के सर्वश्रेष्ठ हैं।

S = struct('A', [1 2], 'B',[3 4 5]); 
S_Cell = struct2cell(S); 
%Then as per gnovice 
for loopIndex = 1:numel(S_Sell) % Loop over the number of cells 
    array = S{loopIndex};   % Access the contents of each cell 
    %# Do stuff with array 
end 

मैं कुछ है कि एक struct में जनरेट किया गया था और उसके बाद मैं एक मैट्रिक्स की तरह इसे का उपयोग करने के लिए आवश्यक के लिए कुछ इसी तरह इस्तेमाल किया, उस मामले में यह उतना ही आसान के रूप में

M = cell2mat(struct2cell(S)); 

एक करने के लिए इसे बदलने के लिए था मैट्रिक्स

Answer 6

बस मिश्रण के लिए एक और जवाब जोड़ने के लिए। मुझे @ निवर से समाधान पसंद है लेकिन यह केवल एक अक्षर नाम वाले फ़ील्ड के लिए काम करता है। समाधान मैं का इस्तेमाल किया गया था:

S = struct('A', [1 2], 'B',[3 4 5], 'Cee', [6 7]); 
for SName = fieldnames(S)' 
    stuff = S.(SName{1}) 
end 

for एक सेल सरणी (इसलिए fieldnames(S)' पर पक्षांतरित के कॉलम के माध्यम से पुनरावृति देगा, इसलिए हम पहली और एकमात्र उपयोग करने के लिए सामग्री अनुक्रमण का उपयोग प्रत्येक पाश के लिए SNAME एक 1x1 सेल सरणी हो जाता है। SName{1} साथ तत्व।