C भाषाको goto स्टेटमेन्ट | मूल संरचना र प्रयोग उदाहरणहरू

1. goto कथन के हो

goto कथन C भाषा मा एक नियन्त्रण संरचना हो, जुन निर्दिष्ट लेबलमा जम्प गरेर प्रोग्रामको प्रवाहलाई नियन्त्रण गर्न प्रयोग गरिन्छ। अन्य धेरै नियन्त्रण संरचनाहरूको विपरीत, goto कथनले प्रोग्रामको कुनै पनि स्थानमा जम्प गर्न सक्ने कारणले, प्रवाहलाई लचिलो रूपमा नियन्त्रण गर्न सक्ने विशेषता हुन्छ। तर, अनियन्त्रित प्रयोगले कोडको पढ्नयोग्यता र मर्मत सम्भावनामा नकारात्मक प्रभाव पार्न सक्छ, त्यसैले सावधानी आवश्यक छ।

goto कथनको मूल संरचना

goto कथनको संरचना तलको जस्तै छ।

goto लेबल;

goto कथन निर्दिष्ट गरिएमा, प्रोग्रामको प्रवाह सम्बन्धित लेबल परिभाषित गरिएको स्थानमा जम्प गर्छ। लेबल भनेको जम्प लक्ष्यको रूपमा निर्दिष्ट गर्ने पहिचानकर्ता हो, र कथनको ठीक अगाडि तलको जस्तै लेखिन्छ।

लेबल नाम:

एक ठोस उदाहरणको रूपमा, सरल प्रोग्राम प्रयोग गरेरgoto कथनको कार्यलाई जाँचौं।

goto कथनको प्रयोग उदाहरण

#include <stdio.h>

int main() {
    int i = 0;

    start: // लेबल परिभाषा
    printf("i को मान: %dn", i);
    i++;

    if (i < 5) {
        goto start; // लेबलमा जम्प
    }

    printf("लूप समाप्तिn");
    return 0;
}

उपरोक्त कोडलेgoto कथन प्रयोग गरेरstart लेबलमा जम्प गर्छ, रi को मान 5 हुने सम्म लूप प्रक्रिया चलाउँछ। यसरी,goto कथन प्रयोग गरेर लेबल निर्दिष्ट गरी इच्छित स्थानमा जम्प गर्न सकिन्छ, तरgoto कथनलाई अत्यधिक प्रयोग गर्दा प्रोग्राम बुझ्न कठिन हुन्छ, त्यसैले सामान्यतया सावधानीपूर्वक प्रयोग गर्न आवश्यक छ।

goto कथनको उपयोग र ध्यान दिनुपर्ने बुँदाहरू

C भाषामाgoto कथनलाई तलका जस्ता अवस्थामा प्रयोग गर्ने विचार गरिन्छ।

• त्रुटि ह्यान्डलिंग: त्रुटि उत्पन्न भएमा, क्रमिक प्रक्रियाहरूलाई स्किप गरेर स्रोतहरू मुक्त गर्ने प्रक्रियामा जम्प गर्न उपयोगी हुन्छ।
• बहु-लेयर लूपको समाप्ति: गहिरो नेस्टेड लूपलाई एकैचोटि बाहिर निस्कनको लागि,goto कथन प्रयोग गर्दा कोड सरल हुन सक्छ।

तर,goto कथनले कोडको प्रवाहलाई जटिल बनाउँछ, त्यसैले विशेष गरी ठूला प्रोग्रामहरूमा सिफारिस गरिँदैन।goto कथनको अत्यधिक प्रयोगले कोड स्प्यागेटी जस्तो बनाउँछ, र मर्मत सम्भावना कठिन बनाउँछ। त्यसैले,goto कथन प्रयोग गर्दा, पढ्नयोग्यता र मर्मत सम्भावनालाई ध्यानमा राखी, उपयुक्त रूपमा प्रयोग गर्नु महत्त्वपूर्ण छ।

2. goto statement को इतिहास र विवाद

goto statement प्रोग्रामिङको प्रारम्भिक भाषाहरूबाट अस्तित्वमा रहेको आधारभूत नियन्त्रण संरचना हो, र C भाषा भन्दा पहिले नै प्रयोग गरिएको छ।तर,goto statement को प्रयोग सम्बन्धी धेरै बहसहरू छन्, र विशेष गरी संरचित प्रोग्रामिङको प्रसारसँगै समर्थन र विरोध विभाजित भएको छ।यो खण्डमा,goto statement को इतिहास र विवादको बारेमा विस्तृत रूपमा व्याख्या गर्नेछौं।

goto statement को उत्पत्ति र प्रारम्भिक भूमिका

प्रोग्रामिङ विकास सुरु भएको बेला, goto statement कोडको नियन्त्रणलाई लक्ष्य स्थानमा जम्प गर्नको लागि एक मात्र उपाय मध्ये एक थियो।प्रारम्भिक भाषाहरूमा अहिलेको जस्तै उन्नत नियन्त्रण संरचना थिएन, र लूप तथा सर्त शाखा कार्यान्वयनमा goto statement को धेरै प्रयोग गरिन्थ्यो।त्यस कारण, त्यस समयमा कार्यक्रमहरू goto statement द्वारा कोडको प्रवाह बारम्बार उड्ने स्वरूपमा बनाइएका थिए।

तर, यो जम्पको धेरै प्रयोग हुने कोडलाई “स्प्यागेटी कोड” भनिन्थ्यो, र जटिल तथा बुझ्न कठिन हुने प्रवृत्ति बढ्यो।यस समस्याको कारण, नियन्त्रणको प्रवाहलाई स्पष्ट बनाउन, सर्त शाखा र लूप संरचनाहरू (if, for, while आदि) परिचय गराइयो, र क्रमशः goto statement को प्रयोग घट्यो।

संरचित प्रोग्रामिङ र goto statement को उपयुक्तता

1970 को दशकमा, प्रसिद्ध कम्प्युटर विज्ञानका विद्वान Edsger Dijkstra ले “goto statement लाई हानिकारक मान्ने” विचार व्यक्त गरे।उनको लेख “goto statement को हानि (Goto Statement Considered Harmful)” ले ठूलो प्रभाव पारेको र संरचित प्रोग्रामिङको व्यापक स्वीकृति को कारण बन्यो।Dijkstra को दाबी अनुसार, goto statement ले कार्यक्रमको नियन्त्रण प्रवाहलाई बुझ्न कठिन बनाउँछ, त्यसैले प्रयोग गर्नु हुँदैन।

संरचित प्रोग्रामिङ भनेको कोडको प्रवाहलाई स्पष्ट र मर्मत गर्न सजिलो बनाउन, लूप तथा सर्त शाखा जस्ता नियन्त्रण संरचनाहरू प्रयोग गरेर लेख्ने विधि हो।यो विधि व्यापक भएकोले, goto statement प्रयोग नगरी कार्यक्रम निर्माण गर्ने सिफारिस गरियो।

आधुनिक समयमा goto statement को स्थिति

वर्तमानमा, अधिकांश प्रोग्रामिङ भाषाहरूमा goto statement सिफारिस गरिँदैन, तर अझै पनि केही केसहरूमा अस्तित्वमा छन्।C भाषा लगायतका केही भाषाहरूमा, विशेष परिस्थितिहरू (जस्तै त्रुटि ह्यान्डलिङ) मा goto statement प्रयोग उपयुक्त मानिन्छ।तर, मूलत: अन्य नियन्त्रण संरचनाहरू (if statement र while statement आदि) प्रयोग गरेर कोड लेख्न सिफारिस गरिन्छ।

यसरी, goto statement को इतिहास र विवाद प्रोग्रामिङको विकाससँग निकट सम्बन्धित छ, र अहिले पनि “goto statement प्रयोग गर्नु उपयुक्त छ कि छैन” बहसको विषय बनिरहन्छ।यद्यपि, कोडको पठनीयता र मर्मतयोग्यताको दृष्टिले, goto statement को प्रयोगलाई सावधानीपूर्वक विचार गर्न आवश्यक छ।

3. goto कथनका फाइदा र बेफाइदा

goto कथनले अन्य नियन्त्रण संरचनाहरूमा प्राप्त गर्न कठिन लचिलो कोड प्रवाह प्राप्त गर्न सक्छ, तर कार्यक्रमको पठनीयता वा मर्मतलाई हानि पुर्याउन सक्छ। यो खण्डमा, goto कथनका फाइदा र बेफाइदाहरू बारे विशिष्ट उदाहरणहरूसँग व्याख्या गर्दछ।

goto कथनका फाइदा

1. जटिल त्रुटि ह्यान्डलिङ सरलीकृत गर्न सकिन्छgoto कथनको एक फाइदाको रूपमा, जटिल त्रुटि ह्यान्डलिङ प्रक्रियालाई सजिलै लागू गर्न सकिन्छ। विशेष गरी, गहिरो नेस्ट भएका सर्त विभाजनहरू धेरै प्रयोग हुने अवस्थामा, त्रुटि उत्पन्न भएमा एक स्थानमा स्रोत मुक्ति वा सफाई गर्न चाहिने हुँदा यो सुविधाजनक हुन्छ।उदाहरण: धेरै स्रोतहरू सुरक्षित गर्दै, त्रुटि उत्पन्न भएमा स्रोतहरू मुक्त गर्ने अवस्था

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

   int main() {
       FILE *file = fopen("example.txt", "r");
       if (!file) {
           printf("फाइल खोल्न सकिएनn");
           goto cleanup; // त्रुटि हुँदा संसाधन मुक्तीमा कूद्नुहोस्
       }

       char *buffer = (char *)malloc(256);
       if (!buffer) {
           printf("स्मृति सुरक्षित गर्न असफल भयोn");
           goto cleanup;
       }

       // यहाँ अन्य प्रक्रिया चलाउनुहोस्

   cleanup:
       if (file) fclose(file);
       if (buffer) free(buffer);
       printf("संसाधन मुक्ती सम्पन्न भयोn");
       return 0;
   }

यो उदाहरणमा, goto कथन प्रयोग गरेर, त्रुटि उत्पन्न भएमा जम्म प्वाइन्टलाई एक स्थानमा समेटेर, स्रोतको मुक्ति प्रक्रियालाई कुशलतापूर्वक गरिएको छ। goto कथन प्रयोग नगरी एकै प्रक्रिया लागू गर्न खोज्दा, जटिल सर्त विभाजन आवश्यक पर्छ र कोड अतिरिक्त लामो हुन सक्छ।

1. बहु-लूपबाट निस्कन सजिलोगहिरो नेस्ट भएका लूपहरूबाट एकैचोटि निस्कन चाहिने अवस्थामा, goto कथन धेरै सुविधाजनक हुन्छ। सामान्य break कथन वा continue कथनले सबैभन्दा भित्री लूपबाट मात्र निस्कन सकिन्छ, त्यसैले गहिरो नेस्ट भएका अवस्थामा goto कथन प्रयोग गर्दा सरल हुन्छ।उदाहरण: दोहोरो लूपबाट एकैचोटि निस्कने अवस्था

for (int i = 0; i < 10; i++) {
       for (int j = 0; j < 10; j++) {
           if (i * j > 30) {
               goto exit_loop; // शर्त पूरा भएमा सबै लूपबाट बाहिर निस्कनुहोस्
           }
           printf("i=%d, j=%dn", i, j);
       }
   }

   exit_loop:
   printf("लूप समाप्तn");

माथिको कोडमा, i * j > 30 भन्ने अवस्था पूरा भएमा, दोहोरो लूपबाट एकैचोटि निस्किएको छ। यो विधि अन्य नियन्त्रण संरचनाहरूमा लागू गर्दा जटिल हुन्छ, तर goto कथन प्रयोग गरेर कोड सरल हुन्छ।

goto कथनका बेफाइदा

1. कोडको पठनीयता घट्छgoto कथन प्रयोग गर्दा, कार्यक्रमको प्रवाह जम्मबाट असम्बद्ध हुन्छ, त्यसैले अन्य विकासकर्ताहरूलाई बुझ्न कठिन हुन्छ। विशेष गरी ठूलो कोड वा लामो समयसम्म मर्मत गरिने कोडमा, goto कथनको प्रयोगले कोडको पठनीयतालाई ठूलो हानि पुर्याउन सक्छ।
2. त्रुटिहरू सजिलै उत्पन्न हुन्छन्goto कथन धेरै प्रयोग हुने कोडमा, कार्यक्रमको प्रवाह पछ्याउन कठिन हुन्छ र अनपेक्षित कार्य वा त्रुटिहरू सजिलै उत्पन्न हुन्छन्। उदाहरणका लागि, जम्म प्वाइन्टमा प्रारम्भीकरण छुटेको वा लेबल अनुपयुक्त स्थानमा राखिएको हुँदा, कार्यक्रमले अपेक्षित नभएको कार्य गर्न सक्छ।
3. स्पागेटी कोडको कारण बन्न सक्छgoto कथन अव्यवस्थित रूपमा प्रयोग गर्दा, कार्यक्रम पूरै जम्मले भरिन्छ र जटिल तथा पढ्न कठिन «स्पागेटी कोड» बन्छ। यो विशेष गरी ठूलो प्रणालीहरूमा स्पष्ट रूपमा देखिने समस्या हो र मर्मतता ठूलो रूपमा घटाउने कारण बन्छ।

समापन

goto कथनमा विशिष्ट अवस्थाहरूमा उपयोगी अवस्थाहरू छन् तर बेफाइदाहरू पनि धेरै छन्। त्यसैले, सामान्यतया अन्य नियन्त्रण संरचनाहरू प्रयोग गर्न सिफारिस गरिन्छ। तथापि, त्रुटि ह्यान्डलिङ वा बहु-लूपबाट निस्कन जस्ता goto कथन प्रभावकारी हुने अवस्थाहरू पनि छन्, त्यसैले अवस्थानुसार सावधानीपूर्वक प्रयोग गर्नु महत्वपूर्ण छ।

4. goto कथनको उपयुक्त प्रयोग उदाहरण

goto कथन नियन्त्रण संरचनाको एक प्रकारको रूपमा, विशेष परिस्थितिहरूमा उपयोगी रूपमा कार्य गर्न सक्छ। यस खण्डमा, goto कथनलाई उपयुक्त रूपमा प्रयोग गरिने परिदृश्यहरूलाई विशिष्ट उदाहरणहरू सहित व्याख्या गरिन्छ। विशेष गरी त्रुटि ह्यान्डलिङ र बहु लूपबाट बाहिर निस्कनुमा केन्द्रित गरी व्याख्या गरिन्छ।

त्रुटि ह्यान्डलिङमा goto कथनको प्रयोग

C भाषा मा अपवाद ह्यान्डलिङको लागि संरचना (जस्तै try-catch) नभएको कारण, बहु स्रोतहरू व्यवस्थापन गर्दा goto कथन उपयोगी हुन्छ।goto कथन प्रयोग गरेर, त्रुटि उत्पन्न भएमा एकै स्थानमा स्रोत मुक्त गर्ने प्रक्रिया लेख्न सकिन्छ, जसले कोडलाई संक्षिप्त बनाउँछ।

उदाहरण: बहु स्रोतहरू सुरक्षित गर्ने प्रक्रियामा त्रुटि ह्यान्डलिङ

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

int main() {
    FILE *file1 = NULL;
    FILE *file2 = NULL;
    char *buffer = NULL;

    file1 = fopen("file1.txt", "r");
    if (!file1) {
        printf("file1.txt खोल्न सकिएनn");
        goto error;  // त्रुटि ह्यान्डलिङको लागि जम्प
    }

    file2 = fopen("file2.txt", "r");
    if (!file2) {
        printf("file2.txt खोल्न सकिएनn");
        goto error;
    }

    buffer = (char *)malloc(1024);
    if (!buffer) {
        printf("स्मृति सुरक्षित गर्न असफल भयोn");
        goto error;
    }

    // अन्य प्रक्रिया यहाँ कार्यान्वयन गर्नुहोस्
    printf("फाइल र स्मृति सञ्चालन सफलतापूर्वक सम्पन्न भयोn");

    // स्रोतहरू मुक्त गर्ने
    free(buffer);
    fclose(file2);
    fclose(file1);
    return 0;

error:
    if (buffer) free(buffer);
    if (file2) fclose(file2);
    if (file1) fclose(file1);
    printf("त्रुटि भएको कारण स्रोतहरू मुक्त गरियोn");
    return -1;
}

यो कोडमा, goto कथन प्रयोग गरेर, त्रुटि उत्पन्न भएको बिन्दुमा एकै साथ स्रोत मुक्त गर्ने प्रक्रिया गरिन्छ। यस प्रकारको त्रुटि ह्यान्डलिङ विधि कोडको नेस्टिङलाई कम बनाउँछ, पढ्न सजिलो बनाउँछ, र स्मृति वा फाइल व्यवस्थापन आवश्यक पर्ने परिस्थितिहरूमा प्रभावकारी हुन्छ।

बहु लूपबाट बाहिर निस्कनु

बहु लूपहरू नेस्टेड भएको अवस्थामा विशेष शर्त पूरा भएमा सबै लूपहरू एकै पटक बाहिर निस्कन चाहनुहुन्छ भने, goto कथन प्रयोग गर्दा सरल रूपमा कार्यान्वयन गर्न सकिन्छ। सामान्य break वा continue कथनहरूले केवल सबैभन्दा भित्री लूप मात्र नियन्त्रण गर्न सक्छन्, त्यसैले जटिल लूप संरचनामा goto कथन अधिक प्रभावकारी हुन्छ।

उदाहरण: द्वि-लूपबाट शर्त पूरा भएमा एकै पटक बाहिर निस्कनु

#include <stdio.h>

int main() {
    int i, j;
    for (i = 0; i < 10; i++) {
        for (j = 0; j < 10; j++) {
            if (i * j > 30) {
                goto exit_loop;  // शर्त पूरा भएमा लूप समाप्त गर्नुहोस्
            }
            printf("i = %d, j = %dn", i, j);
        }
    }

exit_loop:
    printf("शर्त पूरा भएको कारण लूप समाप्त गरियोn");
    return 0;
}

उपरोक्त उदाहरणमा, i * j > 30 शर्त पूरा भएमा द्वि-लूपलाई एकै पटक बाहिर निस्कनको लागि goto कथन प्रयोग गरिएको छ। यो विधि अन्य नियन्त्रण संरचनामा कार्यान्वयन गर्दा जटिल हुन सक्छ, तर goto कथन प्रयोग गर्दा कोड संक्षिप्त हुन्छ।

goto कथनको प्रयोग विचार गर्नुपर्ने परिस्थितिहरू

• स्रोतको मुक्ती: बहु स्रोतहरू सुरक्षित गर्दा तिनीहरूको मुक्ती प्रक्रिया जटिल भएमा, त्रुटि ह्यान्डलिङको एक भागको रूपमा goto कथन प्रयोग गर्नु प्रभावकारी हुन्छ।
• गहिरो लूपको रोकथाम: बहु लूप आवश्यक हुँदा, विशेष शर्त पूरा भएमा सबै लूपहरू एकै पटक बाहिर निस्कन चाहनुहुन्छ भने प्रभावकारी हुन्छ।

goto कथनको प्रयोगमा सावधानी

goto कथनको प्रयोग सुविधाजनक भए पनि, कोडको पठनीयता घट्न सक्छ। त्यसैले प्रयोग गर्दा अन्य नियन्त्रण संरचनाले प्रतिस्थापन गर्न सकिन्छ कि भनेर विचार गरी, आवश्यक न्यूनतममा राख्नु राम्रो हुन्छ। विशेष गरी, ठूलो कोडमा स्प्यागेटी कोड बन्न नदिन प्रयोगलाई न्यूनतममा राख्नु महत्वपूर्ण छ।

5. goto वाक्यलाई टाढा राख्नुपर्ने केसहरू र विकल्पहरू

gotoवाक्य विशेष परिस्थितिहरूमा उपयोगी हुन्छ, तर धेरै प्रयोग गर्दा कोडको पढ्नयोग्यता र मर्मतयोग्यतामा असर पार्ने जोखिम हुन्छ। प्रोग्राम जटिल भएमा, जम्प गन्तव्यलाई पछ्याउन गाह्रो हुन्छ, जसले बगको कारण बन्न सक्छ। यस खण्डमा, gotoवाक्यलाई टाढा राख्नुपर्ने परिस्थितिहरू र त्यसका विकल्पहरूबारे व्याख्या गरिन्छ।

gotoवाक्यलाई टाढा राख्नुपर्ने केसहरू

1. पढ्नयोग्यता महत्त्वपूर्ण कोड
   gotoवाक्यले कोडको प्रवाहलाई बीचमा जम्प गराउँछ, जसले अन्य विकासकर्ताहरूले कोड पढ्दा बुझ्न गाह्रो बनाउँछ। विशेष गरी, ठूलो परियोजना वा अन्य व्यक्तिहरूसँग सहकार्य गर्दा, gotoवाक्यको प्रयोग टाढा राख्नु राम्रो हुन्छ।
2. संरचित त्रुटि ह्यान्डलिङ सम्भव हुने अवस्थामा
   धेरै प्रोग्रामिङ भाषाहरूमा, संरचित त्रुटि ह्यान्डलिङ (अपवाद प्रक्रिया) सम्भव छ, र C भाषामा पनि डिजाइन अनुसार, gotoवाक्य बिना त्रुटि प्रक्रिया गर्न सकिन्छ। उदाहरणका लागि, कार्यहरूलाई विभाजन गरेर त्रुटि प्रक्रिया गर्दा, कोडको पढ्नयोग्यता र मर्मतयोग्यता सुधार हुन्छ।
3. गहिरो नेस्टभित्रको प्रवाह नियन्त्रण
   गहिरो नेस्ट संरचनामा gotoवाक्य प्रयोग गरेर जम्प गर्दा, स्प्यागेटी कोड बन्ने जोखिम बढ्छ। नेस्ट गहिरो हुँदा, फ्ल्याग भेरिएबल वा अन्य नियन्त्रण संरचना प्रयोग गरेर, gotoवाक्य बिना समान प्रवाह प्राप्त गर्न धेरै केसहरूमा सम्भव हुन्छ।

gotoवाक्यका विकल्पहरू

gotoवाक्य बिना समान कार्यक्षमता हासिल गर्नका लागि केही विकल्पहरू प्रस्तुत गरिन्छ।

1. फ्ल्याग भेरिएबल प्रयोग गरेर नियन्त्रण

बहु-लूपबाट बाहिर निस्कन चाहनुहुन्छ भने, फ्ल्याग भेरिएबल प्रयोग गरेर समान नियन्त्रण सम्भव हुन्छ।gotoवाक्य टाढा राख्न, समाप्ति फ्ल्याग सेट गरी, सर्त अनुसार लूपलाई रोक्ने विधि हो।

उदाहरण: फ्ल्याग भेरिएबल प्रयोग गरेर बहु-लूप समाप्त गर्ने

#include <stdio.h>

int main() {
    int i, j;
    int exit_flag = 0;

    for (i = 0; i < 10; i++) {
        for (j = 0; j < 10; j++) {
            if (i * j > 30) {
                exit_flag = 1;  // फ्ल्याग सेट गरेर लूप समाप्त गर्ने निर्देशन
                break;
            }
            printf("i = %d, j = %dn", i, j);
        }
        if (exit_flag) break;  // बाह्य लूप पनि समाप्त
    }

    printf("लूप समाप्तn");
    return 0;
}

यस विधिमा, फ्ल्याग भेरिएबल प्रयोग गरेर समाप्ति सर्त व्यवस्थापन गरेर, gotoवाक्य बिना बहु-लूपबाट बाहिर निस्कन सकिन्छ। कोड सरल हुन्छ, उद्देश्य स्पष्ट हुन्छ, जसले अन्य विकासकर्ताहरूलाई पढ्न सजिलो बनाउँछ।

2. कार्य विभाजनद्वारा त्रुटि ह्यान्डलिङ

gotoवाक्य त्रुटि ह्यान्डलिङमा प्रयोग हुने केसहरूमा, कार्यलाई सानो भागमा विभाजन गरेर त्रुटि प्रक्रिया व्यवस्थापन गर्दा, gotoवाक्य बिना व्यवस्थित गर्न सकिन्छ। यसले कोडको पुन: प्रयोगयोग्यता सुधार्छ, परीक्षण सजिलो बनाउँछ।

उदाहरण: कार्य प्रयोग गरेर त्रुटि ह्यान्डलिङ

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

int read_file(FILE **file, const char *filename) {
    *file = fopen(filename, "r");
    if (!*file) {
        printf("%s खोल्न सकेनn", filename);
        return -1;
    }
    return 0;
}

int allocate_memory(char **buffer, size_t size) {
    *buffer = (char *)malloc(size);
    if (!*buffer) {
        printf("स्मृति सुरक्षित गर्न असफल भयोn");
        return -1;
    }
    return 0;
}

int main() {
    FILE *file1 = NULL;
    char *buffer = NULL;

    if (read_file(&file1, "file1.txt") < 0) {
        return -1;
    }

    if (allocate_memory(&buffer, 1024) < 0) {
        fclose(file1);
        return -1;
    }

    // अन्य प्रक्रिया

    free(buffer);
    fclose(file1);
    printf("प्रक्रिया सफलतापूर्वक समाप्त भयोn");
    return 0;
}

यस उदाहरणमा, फाइल खोल्ने प्रक्रिया र मेमोरी सुरक्षित गर्ने प्रक्रियालाई अलग कार्यमा विभाजन गरी, प्रत्येकले त्रुटि फिर्ता गर्ने बनाइएको छ। यसले त्रुटि उत्पन्न हुँदा, gotoवाक्य प्रयोग नगरी, व्यक्तिगत रूपमा त्रुटि प्रक्रिया गर्न सम्भव बनाउँछ।

3. break वा continue प्रयोग गर्ने

लूपबाट बाहिर निस्कन gotoवाक्य प्रयोग गर्न चाहनुहुन्छ भने, break वा continue प्रयोग गर्न सकिन्छ। यी संरचनाहरू सबैभन्दा भित्री लूपमा मात्र प्रभावी हुन्छन्, तर नेस्ट उथलो भएमा विकल्पको रूपमा पर्याप्त हुन्छ।

सारांश

gotoवाक्य शक्तिशाली नियन्त्रण संरचना हो, तर उपयुक्त नहुनु पर्ने अवस्थामा प्रयोग गर्दा कोड बुझ्न गाह्रो बनाउँछ, मर्मत लागत बढ्छ। विकल्पको रूपमा, फ्ल्याग भेरिएबल, कार्य विभाजन, break र continue प्रयोग गरेर, कोडको पढ्नयोग्यता र मर्मतयोग्यता कायम राख्दै समान नियन्त्रण हासिल गर्न सकिन्छ।gotoवाक्यको प्रयोग अन्तिम उपायको रूपमा मानिनु पर्छ, पहिले यी विकल्पहरू विचार गर्न सिफारिस गरिन्छ।

6. goto कथन सम्बन्धी सर्वोत्तम अभ्यासहरू

goto कथन एक शक्तिशाली र लचिलो नियन्त्रण संरचना हो, तर गलत प्रयोगले कोडको पढ्नयोग्यता र मर्मतयोग्यतामा नकारात्मक प्रभाव पार्न सक्छ। त्यसैले, यस खण्डमा, goto कथन प्रयोग गर्दा ध्यान दिनुपर्ने सर्वोत्तम अभ्यासहरू प्रस्तुत गरिन्छ। यी मार्गनिर्देशनहरू पालना गरेर, goto कथन प्रयोग गर्दा पनि, पढ्न सजिलो र मर्मत गर्न सजिलो कोड कायम गर्न सकिन्छ।

सर्वोत्तम अभ्यास 1: आवश्यक न्यूनतम दायरामा प्रयोग गर्नुहोस्

goto कथन कोडको प्रवाहलाई जम्प गर्नको लागि एक शक्तिशाली उपकरण हो, त्यसैले विशेष गरी त्रुटि ह्यान्डलिंग र बहु-लूपबाट बाहिर निस्कनमा मात्र प्रयोग गर्न सिफारिस गरिन्छ। धेरै प्रोग्रामिङ भाषाहरूमा, goto कथन प्रयोग नगरी पनि नियन्त्रणका लागि पर्याप्त संरचनाहरू उपलब्ध छन्, त्यसैले पहिले goto बाहेकका विकल्पहरू विचार गरौं। goto कथन प्रयोग गर्नु भनेको, अन्य विधिहरू अत्यधिक दोहोरिएमा मात्र उपयुक्त हुन्छ।

सर्वोत्तम अभ्यास 2: स्रोत मुक्तिकरण र सफाईको लागि प्रयोग गर्नुहोस्

C भाषा मा, स्मृति व्यवस्थापन वा फाइल बन्द गर्न बिर्सिएर बगहरू सहजै उत्पन्न हुन्छन्, त्यसैले त्रुटि उत्पन्न हुँदा एकै पटक स्रोत मुक्त गर्न goto कथन प्रभावकारी हुन्छ। स्रोत मुक्तिकरण प्रक्रिया एकत्रित गरेर, कोडको स्पष्टता बढ्छ र स्मृति लीक जस्ता समस्याहरूलाई रोक्न सकिन्छ।

उदाहरण: स्रोत मुक्तिकरणको लागि goto कथन

FILE *file = fopen("example.txt", "r");
if (!file) {
    goto cleanup; // यदि फाइल खोल्न सकिएन भने, स्रोत मुक्त गर्ने स्थानमा जाँदैछ
}

char *buffer = (char *)malloc(1024);
if (!buffer) {
    goto cleanup; // यदि मेमोरी सुरक्षित गर्न असफल भए पनि, स्रोत मुक्त गर्ने स्थानमा जाँदैछ
}

// अन्य प्रक्रिया

cleanup:
if (buffer) free(buffer);
if (file) fclose(file);

यसरी, goto कथन प्रयोग गरेर स्रोत मुक्तिकरण प्रक्रिया एकै स्थानमा समेट्दा, त्रुटि ह्यान्डलिंग सरल हुन्छ।

सर्वोत्तम अभ्यास 3: लेबल नामलाई बुझ्न सजिलो बनाउनुहोस्

लेबल नाम goto कथनको जम्प गन्तव्यलाई स्पष्ट रूपमा देखाउनको लागि संकेतकको रूपमा काम गर्छ। अस्पष्ट लेबल नाम प्रयोग गर्दा, जम्प गन्तव्य के संकेत गर्छ भन्ने बुझ्न कठिन हुन्छ, त्यसैले बुझ्न सजिलो नाम दिनु महत्त्वपूर्ण छ। उदाहरणका लागि, cleanup र error जस्ता, जम्प गन्तव्यको भूमिका स्पष्ट हुने नाम प्रयोग गरौं।

सर्वोत्तम अभ्यास 4: अत्यधिक प्रयोग नगर्नु

goto कथनको अत्यधिक प्रयोगले कोड स्प्यागेटी जस्तो बनाउँछ, जसले मर्मत कठिन बनाउँछ। कोड जटिल हुन सजिलो भएकाले, goto कथनलाई सावधानीपूर्वक प्रयोग गर्नु पर्छ। विशेष गरी धेरै goto कथनहरू बिचमा घुम्ने कोडले अन्य विकासकर्ताहरूलाई बुझ्न समय लाग्ने मात्र होइन, बगहरू उत्पन्न हुने जोखिम पनि बढाउँछ।

सर्वोत्तम अभ्यास 5: अन्य नियन्त्रण संरचनासँग संयोजन नगर्नु

goto कथनलाई अन्य नियन्त्रण संरचनाहरू (if, while, for आदि) सँग जटिल रूपमा संयोजन गर्दा, प्रोग्रामको प्रवाह अनुमान गर्न कठिन हुन्छ। लूप वा सर्त विभाजनभित्र goto कथनको अत्यधिक प्रयोगले, कुन सर्तमा कुन भागमा जम्प गर्ने निर्णय कठिन बनाउँछ, र कोड जटिल हुन्छ। goto कथन प्रयोग गर्दा, सकेसम्म अन्य नियन्त्रण संरचनासँग मिश्रण नगरी, एक्लै प्रयोग गर्नु राम्रो हुन्छ।

सर्वोत्तम अभ्यास 6: कोड समीक्षा पूर्ण रूपमा गर्नु

goto कथन समावेश गर्ने कोडको समीक्षा विशेष गरी महत्त्वपूर्ण छ। अन्य विकासकर्ताहरूले कोडको उद्देश्य बुझ्न र सही रूपमा काम गर्छ कि छैन जाँच गर्न, कोड समीक्षाद्वारा goto कथनको प्रयोग साँच्चिकै आवश्यक छ कि छैन, अन्य उपायले बदल्न सकिन्छ कि छैन पुनरावलोकन गर्नु उचित हुन्छ। कोड समीक्षाद्वारा, goto कथनको प्रयोग उपयुक्त छ कि छैन जाँच गरी, आवश्यक परे सुधार गरिन्छ।

सारांश

goto कथनलाई सही प्रयोग बुझेर, सावधानीपूर्वक प्रयोग गर्दा, प्रभावकारी रूपमा प्रोग्रामको प्रवाह नियन्त्रण गर्न सकिन्छ। तर, प्रयोग गर्दा, पढ्नयोग्यता र मर्मतयोग्यतामा जोड दिनु, अन्य विकासकर्ताहरूले बुझ्न सजिलो कोड बनाउने प्रयास गर्नु महत्त्वपूर्ण छ। विशेष गरी, goto कथन प्रयोग गर्ने अवस्थामा, स्रोत मुक्तिकरण वा त्रुटि ह्यान्डलिंग जस्ता सीमित परिस्थितिमा प्रयोग गरी, सकेसम्म अत्यधिक प्रयोग नगर्नु सिफारिस गरिन्छ।

7. सारांश

यस लेखमा, C भाषा को goto कथनको बारेमा, आधारभूत प्रयोग विधिबाट ऐतिहासिक पृष्ठभूमि, फाइदाहरू र बेफाइदाहरू, उपयुक्त प्रयोग उदाहरणहरू, टाढा राख्नुपर्ने केसहरू र विकल्पहरू, साथै सर्वोत्तम अभ्याससम्म विस्तृत रूपमा व्याख्या गरिएको छ।goto कथन अत्यन्त लचिलो र शक्तिशाली नियन्त्रण संरचना हो, तर प्रयोग गर्दा सावधानी आवश्यक हुन्छ।

goto कथनलाई बुझ्न, सावधानीपूर्वक प्रयोग गर्नुहोस्

goto कथन विशेष परिदृश्यहरूमा, विशेष गरी त्रुटि ह्यान्डलिङ वा गहिरो नेस्टेड लूपबाट बाहिर निस्कनमा प्रभावकारी हुन्छ, तर अत्यधिक प्रयोग गर्दा कोडको पढ्नयोग्यता र मर्मतयोग्यतामा नकारात्मक प्रभाव पर्न सक्छ। अन्य नियन्त्रण संरचनाहरू उपलब्ध भएमा, goto कथनलाई टाढा राख्न सिफारिस गरिन्छ। थप रूपमा, goto कथनको लेबल नाम स्पष्ट बनाइ, स्रोत मुक्त गर्ने जस्ता सीमित प्रयोगहरूमा मात्र प्रयोग गर्दा, कोडको स्पष्टता सुधारिन्छ र उद्देश्य स्पष्ट भएको प्रोग्राम लेख्न सकिन्छ।

सर्वोत्तम अभ्यासहरू पालना गरी प्रभावकारी रूपमा प्रयोग गर्नुहोस्

goto कथन प्रयोग गर्दा, यस लेखमा प्रस्तुत गरिएको सर्वोत्तम अभ्यासहरूलाई ध्यानमा राखी, पढ्नयोग्यता र मर्मतयोग्यतामा जोड दिनुहोस्। विशेष गरी, आवश्यक न्यूनतम दायरा मात्र प्रयोग गर्नु, स्रोत मुक्त गर्ने वा त्रुटि ह्यान्डलिङको लागि प्रयोग गर्नु, र लेबललाई बुझ्न सजिलो नाम दिनु महत्त्वपूर्ण छ। यी बुँदाहरूलाई ध्यानमा राखेर, goto कथनलाई उपयुक्त रूपमा प्रयोग गर्दा, अन्य विकासकर्ताहरूका लागि पनि बुझ्न सजिलो कोड प्राप्त गर्न सकिन्छ।

सारांश

C भाषा को goto कथन नियन्त्रण संरचना रूपमा देख्दा सरल देखिन्छ, तर उपयुक्त प्रयोग बुझ्न आवश्यक छ। प्रभावकारी कोड लेख्नको लागि, goto कथनलाई अन्य नियन्त्रण संरचनासँग मिश्रण नगरी, सावधानीपूर्वक प्रयोग गर्नु महत्त्वपूर्ण छ। कार्यक्रमको आकार वा स्थितिको आधारमा, goto कथन उपयुक्त छ कि छैन निर्धारण गरी, आवश्यक परे विकल्पहरू विचार गरेर, मर्मतयोग्य कोड लक्ष्य बनाउनुहोस्।