c - सी में स्टैक चर के ऑटो रिलीज




variables macros (2)

आप जीसीसी में क्लीनअप वेरिएबल एट्रिब्यूट का उपयोग कर सकते हैं। कृपया इसे देखें: http://echorand.me/site/notes/articles/c_cleanup/cleanup_attribute_c.html

नमूना कोड:

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

void free_memory(void **ptr)
{
    printf("Free memory: %p\n", *ptr);
    free(*ptr);
}

int main(void)
{
    // Define variable and allocate 1 byte, the memory will be free at
    // the end of the scope by the free_memory function. The free_memory 
    // function will get the pointer to the variable *ptr (double pointer
    // **ptr).
    void *ptr  __attribute__ ((__cleanup__(free_memory))) = malloc(1);
    return 0;
}

यदि आप स्रोत कोड को main.c नामक फ़ाइल में सहेजते हैं, तो आप इसे इस कमांड से संकलित कर सकते हैं:

gcc main.c -o main

और सत्यापित करें कि क्या कोई मेमोरी लीक है:

valgrind ./main

Valgrind से उदाहरण आउटपुट:

==1026== Memcheck, a memory error detector
==1026== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==1026== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==1026== Command: ./main
==1026== 
Free memory: 0x51ff040
==1026== 
==1026== HEAP SUMMARY:
==1026==     in use at exit: 0 bytes in 0 blocks
==1026==   total heap usage: 1 allocs, 1 frees, 1 bytes allocated
==1026== 
==1026== All heap blocks were freed -- no leaks are possible
==1026== 
==1026== For counts of detected and suppressed errors, rerun with: -v
==1026== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

दुर्भाग्यवश, सी में कोई स्मार्ट पॉइंटर्स नहीं हैं .. लेकिन क्या एक मैक्रो बनाना संभव है जो वैरिएबल घोषणा को लपेटता है और उस वैरिएबल के साथ फंक्शन कॉल को इनपुट वैरिएबल के रूप में बुलाता है जहां वेरिएबल घोषित किया गया था?

लंबे वाक्यांश के लिए खेद है, लेकिन मैं xnu कर्नेल पर काम कर रहा हूं, जहां आपके पास कई तत्व हैं जिनमें अंतर्निहित संदर्भ काउंटर हैं, और किसी को स्मृति लीक से बचने के लिए इसका उपयोग करते समय इस तत्व को अपरिवर्तित करना नहीं भूलना चाहिए।

उदाहरण के लिए, यदि मेरे पास निम्न प्रकार का proc_t :

struct proc;
typedef struct proc * proc_t;

मैं इस प्रकार के आधार पर एक स्टेप वैरिएबल घोषित करना चाहता हूं, उदाहरण के लिए:

{
    proc_t_release_upon_exit proc_t proc_iter = proc_find(mypid);
    //the rest of the code in this scope 
}

प्रीप्रोसेसर मैक्रो का विश्लेषण करने और संकलन से पहले, निम्न कोड उत्पन्न होने की उम्मीद है:

{ 
    proc_t myproc = proc_find(mypid)
    //the rest of the code in scope
    proc_rele(myproc);
}

सी में इस तरह के मैक्रो को परिभाषित करने का कोई तरीका है?


मुझे पता है कि यह वह नहीं है जिसे आप सुनना चाहते हैं, लेकिन मैं आपसे आग्रह करता हूं कि ऐसा न करें।

यह पूरी तरह से स्वीकार्य सी शैली है जो रिटर्न का एक बिंदु है, इससे पहले कि सब कुछ साफ हो जाए। चूंकि कोई अपवाद नहीं है, इसलिए यह करना आसान है, और फ़ंक्शन को देखकर सत्यापित करना आसान है।

ऐसा करने के लिए मैक्रो-हैकरी या कंपाइलर "फीचर्स" का उपयोग करना सी शैली स्वीकार नहीं किया जाता है। पढ़ने और समझने के बाद हर किसी के लिए यह बोझ होगा। और अंत में यह वास्तव में आपको ज्यादा लाभ नहीं देता है।





macros