क्या मैं फ़ंक्शन में डबल * वापस कर सकता हूं?

Question

क्या मैं ऐसा कुछ कर सकता हूं? यह काम करेगा?

double *vec_subtraction (char *a, char *b, int n) 
{ 
    double *result; 
    int i; 

    for(i=0; i<n; i++) 
     result[i] = a[i]-b[i]; 

    return result; 
} 

और फिर मुख्य में:

double *vec=vec_substraction(a, b, n); 
for(i=1; i<n; i++)   
    printf("%d", vec[i]); 

ए और बी तत्वों की एक ही नंबर के साथ वैक्टर हैं, n तत्वों की संख्या है।

Answer 1

हाँ आप कर सकते हैं, लेकिन आपको कहीं भी result के लिए स्मृति आवंटित करने की आवश्यकता है।

असल में, आप या तो vec_subtraction या vec_subtraction के अंदर मेमोरी आवंटित कर सकते हैं, यदि आप बाहर आवंटित करते हैं तो आप इसे स्थिर या गतिशील रूप से कर सकते हैं।

आप अंदर आवंटित करने के लिए जा रहा है, तो कर रहे हैं:

double *vec_subtraction (char *a, char *b, int n) { 
    double *result = malloc(sizeof(double)*n); 
    int i; 
    for(i=0; i<n; i++) 
     result[i] = a[i]-b[i]; 

    return result; 
} 

और मुख्य में:

double *vec; 
// ... 
vec = vec_subtraction(a, b, n); 
// ... 
free(vec); 

कुछ देर बाद vec_subtraction करने के लिए कॉल का परिणाम free के लिए मत भूलना।

---

आप आवंटित करने के लिए जा रहे हैं आप बाहर याद करने के लिए एक सूचक में पारित करने के लिए की जरूरत है:

void vec_subtraction (char *a, char *b, int n, double *result) { 
    int i; 
    for(i=0; i<n; i++) 
     result[i] = a[i]-b[i]; 
} 

मुख्य में

:

// choose one of: 
// double *vec = malloc(sizeof(double)*n); 
// double vec[10]; // where 10= n. 
vec_subtraction(a, b, n, vec); 

// if you used *vec = malloc... remember to call free(vec). 

Answer 2

आप कर सकते हैं, लेकिन आप डॉन ' प्रतीत होता है वे परिणाम वेक्टर के लिए किसी भी स्मृति आवंटित किया प्रतीत होता है।

Answer 3

यदि आप परिणामों के लिए किसी भी स्मृति आवंटित यह काम करेगा:

result = malloc(sizeof(*result) * n); 

और अब यह है कि स्मृति को मुक्त करने के फोन करने वाले की जिम्मेदारी बन जाती है।

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

Answer 4

ऐसा नहीं है। फ़ंक्शन में या फ़ंक्शन के भीतर से ढेर पर कॉल करने से पहले आपको या तो स्टैक पर मेमोरी आवंटित करने की आवश्यकता है।

double *vec_subtraction(...) { 
    double *result = malloc(sizeof(double)*n); 

    ... 

    return result; 
} 

फिर बाकी काम करेंगे। हालांकि आपको याददाश्त मुक्त करने की याद रखना चाहिए।

चारा नहीं है:

void vec_subtraction(..., double *result) { 


     ... 

} 

मुख्य में

तब:

double result[n]; 
vec_subtraction(..., result); 

Answer 5

आप निश्चित रूप से एक समारोह से एक डबल * लौट सकते हैं। बस सुनिश्चित करें कि सूचक अभी भी एक वैध वस्तु को इंगित करता है। जैसेयह मत करो:

double *vec_subtraction (char *a, char *b, int n) { 
double result[n]; 
int i; 

for(i=0; i<n; i++) 
    result[i] = a[i]-b[i]; 

    return &result[0]; //error,the local array will be gone when the function returns. 
} 

यह हालांकि ठीक होगा:

double *vec_subtraction (char *a, char *b, int n) { 
double *result = malloc(sizeof(double)*n); 
int i; 
if(result == NULL) 
    return NULL; 

for(i=0; i<n; i++) 
    result[i] = a[i]-b[i]; 

    return result; //remember to free() the returned pointer when done. 
} 

Answer 6

अपने vec_subtraction समारोह में आप डबल * परिणाम में एक uninitialised चर है। यदि आप इसे कुछ अर्थपूर्ण वापस लौटना चाहते हैं तो आपको सरणी में कुछ मेमोरी आवंटित करने की आवश्यकता है, उदा।

result = malloc(sizeof(double) * n); 

तो फिर तुम यह मुक्त करने के लिए याद करने के लिए यह करने के बाद है:

free(vec); 

हालांकि, अच्छा अभ्यास (कम से कम जब मैं एक सी-सांकेतिक शब्दों में बदलनेवाला था) स्मृति और स्मृति alloc करने के लिए था एक ही दायरे में, जहां संभव हो। तो वास्तव में आपको अपने सरणी को अपने vec_subtraction फ़ंक्शन में पास करना चाहिए। आप करने के लिए अपने समारोह के हस्ताक्षर को बदलना होगा:

vec_subtraction (char *a, char *b, int n, double *result) 

इस तरह यह बुला:

double vec[n]; 
... 
vec_subtraction (a, b, n, &result); 

कीजिए मेरी छद्म ग, लेकिन उम्मीद है कि आपको अंदाजा हो।

शुभकामनाएं!

Answer 7

आप इसे बहुत ज्यादा इसे पसंद नहीं है जब तक कि कुछ इस तरह कर सकते हैं। विशेष रूप से, आपको यह आश्वस्त करने की आवश्यकता है कि आप उचित रूप से सभी मेमोरी के जीवनकाल को संभालने में सक्षम हैं।

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

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