क्या मेरे फ़ंक्शन को गतिशील सरणी वापस करने का कोई तरीका है?

Question

तो फिलहाल मेरे पास एक फ़ंक्शन है जिसे मैंने स्थिर सरणी लौटा दी है, क्या यह दक्षता के लिए गतिशील सरणी बनाने का कोई तरीका है?

#include <stdio.h> 
#include <stdlib.h> 
#include "header.h" 

int *charpos(char *str, char ch) 
{ 
    int *bff, bc, ec, i, strln; 
    static int ret[255]; 
    bc = 0; 
    ec = 0; 

    for(i = 0; str[i] != '\0'; i++) 
     ; 

    strln = i; 
    for(i = 0; i <= strln; i++) 
    { 
     if(str[i] == ch) 
      ec++; 
    } 

    bff = malloc(sizeof(int)*ec); 
    if(sizeof(bff) > sizeof(ret)) 
    { 
     free(bff); 
     return 0; 
    } 

    for(i = 0; i <= 255; i++) ret[i] = '\0'; 
    for(i = 0; i <= strln; i++) 
    { 
     if(str[i] == ch) 
     { 
      ret[bc] = i; 
      bc++; 
     } 
    } 

    free(bff); 
    return ret; 
} 

Answer 1

कार्य arrays, अवधि वापस नहीं कर सकते हैं। आप निश्चित रूप से एक सूचक हो सकते हैं या कॉलर द्वारा आवंटित स्मृति के एक ब्लॉक में एक सूचक ले सकते हैं। तो, आपके मामले में ...

int *ret = malloc(255 * sizeof int); // caller must deallocate! 

हालांकि यह आपके कोड के अर्थशास्त्र को बदलता है। आपके फ़ंक्शन का कॉलर अब लौटे पॉइंटर पर free() पर कॉल करने के लिए ज़िम्मेदार है। यदि वे नहीं करते हैं तो आप स्मृति को रिसाव करेंगे, इसलिए इससे कुछ जटिलताएं जुड़ती हैं जो पहले मौजूद नहीं थीं। मैं इसके बजाय कुछ पसंद करूंगा:

void charpos(int *p, size_t size, const char *str, char ch) { 
    // initialize the memory 
    memset(p, 0, size * sizeof int); 

    // your other code here... 

    size_t len = strlen(str); 
    // fill the caller's memory 
    for(i = 0; i < len; ++i) 
    { 
     if(str[i] == ch) 
      p[bc++] = i; 
    } 
} 

यदि मैंने आपके प्रश्न का उत्तर नहीं दिया है तो आपको मेरे लिए (हमें) विस्तृत करने की आवश्यकता है। आप अभी एक सरणी वापस नहीं कर रहे हैं; आप int पर एक पॉइंटर लौट रहे हैं जो स्थिर आवंटित सरणी के पहले तत्व को संदर्भित करता है।

Answer 2

आप वास्तव में अधिक जगह आवंटित कर सकते हैं तो आपको स्थिर int के साथ आवश्यकता है और गतिशीलता के बारे में चिंता करने की आवश्यकता नहीं है। यहाँ कैसे मैं इसे हल है:

//indefinite reads, actually only up to 20 
int * readDataAD7142(int addr, int numRegs){ 
    static int data[20]; 
    int i = 0; 

    //Do something with this data array. Something that requires less then 20 elements 

    return data; 
} 

यहाँ कोड है कि यह कॉल

int *p; 
int i; 
p = readDataAD7142(0x0000, 6); 

for(i=0; i<6; i++){ 
    Serial.println(p[i], HEX); 
} 

बिल्कुल सही और आसान यदि आप और अधिक स्मृति तो आप की जरूरत है और कम समय है (आप थोड़ा आलसी होने की जरूरत है भी)।