एक बड़ी फ़ाइल को C/C++, Java और Python में अलग-अलग मॉड्यूल में विभाजित करें

| | | | | | | | | | |

यह दृष्टिकोण विफलता के लिए अभिशप्त है और आमतौर पर शुरुआत से पुनर्लेखन की आवश्यकता होती है।

इसलिए, इस परिदृश्य को हल करने के लिए, हम समस्या को कई उप-समस्याओं में विभाजित करने का प्रयास कर सकते हैं और फिर इसे एक-एक करके हल करने का प्रयास कर सकते हैं। एक।

यह न केवल हमारे कार्य को आसान बनाता है, बल्कि हमें उच्च स्तर से

अब बड़ा सवाल यह है कि सैद्धांतिक रूप से नहीं, बल्कि सॉफ़्टवेयर को "ब्रेक" कैसे किया जाए।

हम लोकप्रिय भाषाओं में कई अलग-अलग प्रकार की ऐसी इकाइयाँ देखेंगे - जैसे C / C++, पायथन और amp; जावा।

C / C++

उदाहरण के लिए,

मान लें कि हमारे पास एक प्रोग्राम में सभी बुनियादी लिंक्ड लिस्ट इंसर्ट हैं। चूंकि कई विधियाँ (फ़ंक्शन) हैं, हम आवश्यक मुख्य फ़ंक्शन के ऊपर सभी विधि परिभाषाएँ लिखकर प्रोग्राम को अव्यवस्थित नहीं कर सकते। लेकिन अगर हमने किया भी, तो ऑर्डर करने के तरीकों की समस्या हो सकती है, जब एक विधि दूसरे से पहले होनी चाहिए, और इसी तरह।

इसलिए, इस समस्या को हल करने के लिए, हम शुरुआत में सभी प्रोटोटाइप घोषित कर सकते हैं। कार्यक्रम, और फिर मुख्य विधि और उसके नीचे हम उन्हें किसी विशेष क्रम में परिभाषित कर सकते हैं:

कार्यक्रम:

FullLinkedList.c


<टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

// एक पूरी लिंक की गई सूची डालें


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


// ------------ -------------- ------
<कोड वर्ग = "टिप्पणियां"> // घोषणाएं - प्रारंभ करें:
<कोड वर्ग = "टिप्पणियां"> // ------ --------------------------


<कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड;

स्ट्रक्चर Node * create_node ( int <कोड वर्ग = "सादा"> डेटा);

<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य <कोड वर्ग = "सादा"> b_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> डेटा);

<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य <कोड वर्ग = "सादा"> n_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> डेटा, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> स्थिति);

<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य <कोड वर्ग = "सादा"> e_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> डेटा);

<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य <कोड वर्ग = "सादा"> प्रदर्शन ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड * अस्थायी);


// ------------ -------------- ------
<कोड वर्ग = "टिप्पणियां"> // घोषणाएं - अंत:
<कोड वर्ग = "टिप्पणियां"> // ------ --------------------------


<कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> मुख्य ()

<कोड वर्ग = "सादा"> {

<कोड वर्ग = "कीवर्ड बोल्ड"> स्ट्रक्चर <कोड क्लास = "प्लेन"> नोड * हेड = न्यूल;


int ch, data, pos;


printf ( " लिंक की गई सूची: " <कोड वर्ग ="सादा">);

जबकि (1) {

प्रिंटफ <कोड क्लास = "प्लेन"> ( <कोड क्लास = "स्ट्रिंग"> "1.इन्सर्ट एट बिगिनिंग" <कोड क्लास = "प्लेन ">);

प्रिंटफ ( "2.Insert नौवें स्थान पर" <कोड वर्ग = "सादा">);

printf ( "3.Insert समाप्त होने पर" <कोड वर्ग = "सादा">);

printf ( "4.Display " <कोड वर्ग = "सादा">);

printf ( "0.Exit " <कोड वर्ग = "सादा">);

printf ( "अपनी पसंद दर्ज करें :" <कोड वर्ग = "सादा">);

scanf ( "% d" <कोड वर्ग = "सादा">, और amp; ch);


स्विच (ch) {

<कोड वर्ग ="अपरिभाषित रिक्त स्थान"> <कोड वर्ग ="कीवर्ड बोल्ड"> केस <कोड वर्ग ="सादा "> 1:

< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "दर्ज करें डेटा:" <कोड वर्ग = "सादा">);

scanf ( "% d" <कोड वर्ग = "सादा">, और amp; डेटा);

<कोड वर्ग = "सादा"> b_insert (& amp; सिर, डेटा);

ब्रेक ;


केस 2:

< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "दर्ज करें डेटा:" <कोड वर्ग = "सादा">);

scanf ( "% d" <कोड वर्ग = "सादा">, और amp; डेटा);


printf ( " स्थिति दर्ज करें: " );

scanf ( "% d" <कोड वर्ग = "सादा">, और amp; स्थिति);

<कोड वर्ग = "सादा"> n_insert (& amp; सिर, डेटा, स्थिति);

ब्रेक ;


केस 3:

< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "दर्ज करें डेटा:" <कोड वर्ग = "सादा">);

scanf ( "% d" <कोड वर्ग = "सादा">, और amp; डेटा);

<कोड वर्ग = "सादा"> e_insert (& amp; सिर, डेटा);

ब्रेक ;


केस 4:

< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "सादा"> प्रदर्शन (सिर);

ब्रेक ;


केस 0:

< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग =" कीवर्ड बोल्ड "> वापसी <कोड वर्ग = "सादा"> 0;


डिफ़ॉल्ट :

<कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "गलत विकल्प" <कोड वर्ग = "सादा">);

}

}

<कोड वर्ग ="सादा ">}


<कोड वर्ग = "टिप्पणियां"> // ---------------- ---------- ------
// परिभाषाएँ - START:
// ---- ----------------------------


<कोड क्लास = "कीवर्ड बोल्ड"> स्ट्रक्चर <कोड क्लास = "प्लेन"> नोड {

<कोड क्लास = "कलर 1 बोल्ड"> इंट < कोड वर्ग = "सादा"> डेटा;

<कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड * अगला;

<कोड वर्ग = "सादा">};


struct Node * create_node ( int data)

{

< कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड * अस्थायी

<कोड वर्ग = "सादा"> = ( < कोड क्लास = "कीवर्ड बोल्ड"> स्ट्रक्चर <कोड क्लास = "प्लेन"> नोड *)

<कोड क्लास = "फंक्शन बोल्ड"> मॉलोक < कोड वर्ग = "सादा"> ( <कोड वर्ग = "कीवर्ड बोल्ड"> आकार <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड));

<कोड वर्ग = "सादा"> अस्थायी- > डेटा = डेटा;

<कोड वर्ग = "सादा"> अस्थायी- > अगला = शून्य;


रिटर्न temp;

}


void b_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड "> int data)

{

<कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड * new_node = create_node (डेटा);


new_node- > अगला = * सिर;

<कोड वर्ग = "सादा"> * सिर = new_node;

}


void n_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड "> int data, int pos)

{

if (* सिर == NULL) {

<कोड वर्ग = "सादा"> b_insert (सिर, डेटा);

<कोड वर्ग = "कीवर्ड बोल्ड"> वापसी <कोड वर्ग = "सादा">;

}


स्ट्रक्चर <कोड क्लास =" प्लेन "> नोड * new_node = create_node (डेटा);


स्ट्रक्चर Node * temp = * head;


के लिए ( int i = 0; i "pos - 2;++ i)

temp = अस्थायी- > अगला;


new_node- > अगला = अस्थायी- > अगला;

<कोड वर्ग = "सादा"> अस्थायी- > अगला = नया_नोड;

}


void e_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड "> int data)

{

<कोड वर्ग = "कीवर्ड बोल्ड"> अगर <कोड वर्ग = "सादा"> (* सिर == नल) {

<कोड वर्ग = "सादा"> b_insert (सिर, डेटा);

<कोड वर्ग = "कीवर्ड बोल्ड"> वापसी <कोड वर्ग = "सादा">;

}


स्ट्रक्चर <कोड क्लास =" प्लेन "> नोड * टेम्प = * हेड;


जबकि (temp- > next! = NULL)

temp = temp- > अगला;


struct Node * new_node = create_node (डेटा);

<कोड वर्ग = "सादा"> अस्थायी- > अगला = नया_नोड;

}


void प्रदर्शन ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड * अस्थायी)

कोड वर्ग = "सादा"> {

कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "तत्व हैं:" <कोड वर्ग = "सादा">);

जबकि (temp! = NULL) {

<कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "% d" <कोड वर्ग = "सादा" ">, अस्थायी- > डेटा);

<कोड वर्ग = "सादा"> अस्थायी = अस्थायी- > अगला;

}

Printf ( " " );

}


// ------ --------------------------
<कोड वर्ग = "टिप्पणियां"> // परिभाषाएं - END
<कोड वर्ग = "टिप्पणियां"> // --------------------- -----------

कोड संकलित करना: हम उपरोक्त प्रोग्राम को संकलित कर सकते हैं:
हम पहले से ही कार्यक्रम के साथ मुख्य समस्याओं को देख सकते हैं, व्यक्तिगत रूप से या समूह में कोड के साथ काम करना इतना आसान नहीं है।

अगर कोई उपरोक्त के साथ काम करना चाहता है कार्यक्रम, फिर व्यक्ति को जिन समस्याओं का सामना करना पड़ रहा है उनमें से कुछ:

  1. किसी को पूर्ण स्रोत फ़ाइल से गुजरना होगा। कुछ कार्यक्षमता में सुधार या सुधार करने के लिए।
  2. आसानी से पुन: उपयोग नहीं किया जा सकता कार्यक्रम अन्य परियोजनाओं के लिए एक आधार के रूप में।
  3. कोड बहुत अव्यवस्थित है और बिल्कुल भी आकर्षक नहीं है, जिससे कोड के माध्यम से नेविगेट करना बहुत मुश्किल हो जाता है।

एक समूह परियोजना या बड़े कार्यक्रमों के मामले में, उपरोक्त दृष्टिकोण से समग्र लागत, ऊर्जा और विफलता दर में वृद्धि की गारंटी है।

सही तरीका:

हम देखते हैं कि ये पंक्तियाँ हर C / C++ प्रोग्राम में शुरू होती हैं जो "#include" से शुरू होती है।
इसका मतलब है "लाइब्रेरी" हेडर (.h files) में घोषित सभी फ़ंक्शन शामिल करें और संभवतः library.c / cpp फाइलों में परिभाषित करें।

इन पंक्तियों को संकलन समय पर पूर्व-संसाधित किया जाता है।

हम अपने उद्देश्यों के लिए मैन्युअल रूप से ऐसी लाइब्रेरी बनाने का प्रयास कर सकते हैं।

ध्यान रखने योग्य महत्वपूर्ण बातें :

  1. ".h" फाइलों में केवल प्रोटोटाइप डिक्लेरेशन (जैसे फंक्शंस, स्ट्रक्चर्स) और ग्लोबल वेरिएबल्स होते हैं।
  2. ".c / .cpp" फाइलों में वास्तविक कार्यान्वयन (हेडर फाइलों में डिक्लेरेशन डेफिनिशन) होता है
  3. सभी स्रोत फाइलों को संकलित करते समय, सुनिश्चित करें कि एक ही फ़ंक्शन की कई परिभाषाएं, चर, आदि एक ही परियोजना के लिए मौजूद नहीं हैं। (बहुत महत्वपूर्ण)
  4. स्थिर कार्यों, का उपयोग स्वयं को उस फ़ाइल तक सीमित रखने के लिए करें जिसमें उन्हें घोषित किया गया है।
  5. बाहरी कीवर्ड का उपयोग करके संदर्भित चर और बाहरी फ़ाइलों का उपयोग करें।
  6. C++ का उपयोग करते समय, नाम स्थान से सावधान रहें, टकराव से बचने के लिए हमेशा namespace_name:: function (), का उपयोग करें।
  7. प्रोग्राम को छोटे कोड में विभाजित करके:
    उपरोक्त प्रोग्राम की जांच करने के बाद, हम देख सकते हैं कि कैसे इस बड़े प्रोग्राम को उपयुक्त छोटे भागों में विभाजित किया जा सकता है और फिर आसानी से संसाधित।

    उपरोक्त कार्यक्रम में अनिवार्य रूप से 2 मुख्य कार्य हैं:
    1) नोड्स में डेटा बनाएं, डालें और सहेजें।
    2) नोड्स प्रदर्शित करना


    इस तरह मैं प्रोग्राम को तदनुसार विभाजित कर सकता हूं ताकि:
    1) मुख्य फाइल > प्रोग्राम ड्राइवर, इंसर्शन मॉड्यूल से अच्छा रैपर और जहां हम अतिरिक्त फाइलों का उपयोग करते हैं।
    2) पेस्ट - > वास्तविक कार्यान्वयन यहाँ है।

    उल्लिखित महत्वपूर्ण बिंदुओं के साथ, कार्यक्रम को इसमें विभाजित किया गया है:

    linkedlist.c - > ड्राइवर प्रोग्राम शामिल है
    insert.c - > प्रविष्टि के लिए कोड शामिल है

    linkedlist.h - > आवश्यक नोड घोषणाएं शामिल हैं
    insert.h - > आवश्यक नोड प्रविष्टि घोषणाएं शामिल हैं

    प्रत्येक हेडर फ़ाइल में हम इसके साथ शुरू करते हैं:

     #ifndef FILENAME_H #define FILENAME_H घोषणाएं ... #endif 

    जिस कारण से हम #ifndef, #define और #endif, के बीच अपनी घोषणाएं लिखते हैं, वह डेटा प्रकार, चर, आदि जैसे पहचानकर्ताओं की कई घोषणाओं को रोकने के लिए है, जब एक और एक ही हेडर फ़ाइल को कॉल किया जाता है उसी प्रोजेक्ट से संबंधित एक नई फ़ाइल में।

    इस नमूना कार्यक्रम के लिए:

    insert.h - > इसमें सम्मिलित नोड की घोषणा के साथ-साथ नोड की घोषणा भी शामिल है।

    यह याद रखना बहुत महत्वपूर्ण है कि संकलक हेडर फ़ाइल में घोषणाओं को देख सकता है, लेकिन यदि आप कोड लिखने का प्रयास करते हैं तो

    मजबूत> में कहीं और घोषणा शामिल है, इसके परिणामस्वरूप एक त्रुटि होगी, क्योंकि संकलक लिंक चरण पर जाने से पहले प्रत्येक .c फ़ाइल को व्यक्तिगत रूप से संकलित करता है। ,

    connectedlist.h - > एक सहायक फ़ाइल जिसमें नोड और उसके प्रदर्शन घोषणाएं शामिल हैं जिन्हें उनका उपयोग करने वाली फ़ाइलों के लिए शामिल किया जाना चाहिए।


    insert.c - > #include "connectedlist.h", के माध्यम से एक नोड घोषणा शामिल करें जिसमें घोषणा के साथ-साथ insert.h.

    connectedlist.c में घोषित अन्य सभी विधि परिभाषाएं शामिल हैं। - > साधारण रैपर, जिसमें एक अनंत लूप होता है जो उपयोगकर्ता को आवश्यक स्थिति में पूर्णांक डेटा डालने के लिए प्रेरित करता है, और इसमें एक विधि भी होती है जो सूची प्रदर्शित करती है।

    और ध्यान रखने वाली आखिरी बात यह है कि अर्थहीन फ़ाइलों को एक-दूसरे में शामिल करने से कई ओवरराइड हो सकते हैं और इसके परिणामस्वरूप एक त्रुटि होगी।

    उपरोक्त को ध्यान में रखते हुए, आपको सावधानीपूर्वक उपयुक्त रूटीन में विभाजित करना चाहिए।

    लिंक्डलिस्ट।h


    <टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग =" 0 ">

    <कोड क्लास =" टिप्पणियाँ "> // Connectlist.h


    # ifndef LINKED_LIST_H
    # परिभाषित करें LINKED_LIST_H


    struct Node {

    <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> डेटा;

    <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड * अगला;

    <कोड वर्ग = "सादा">};


    void डिस्प्ले ( संरचना <कोड वर्ग = "सादा"> नोड * अस्थायी);


    # endif

    insert.h


    <तालिका सीमा = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

    // insert.h


    # ifndef INSERT_H
    < कोड वर्ग = "प्रीप्रोसेसर"> # परिभाषित करें INSERT_H


    कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड;

    स्ट्रक्चर Node * create_node ( int <कोड वर्ग = "सादा"> डेटा);

    <कोड वर्ग = "कीवर्ड बोल्ड"> शून्य <कोड वर्ग = "सादा"> b_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> डेटा);

    <कोड वर्ग = "कीवर्ड बोल्ड"> शून्य <कोड वर्ग = "सादा"> n_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> डेटा, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> स्थिति);

    <कोड वर्ग = "कीवर्ड बोल्ड"> शून्य <कोड वर्ग = "सादा"> e_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड"> int <कोड वर्ग = "सादा"> डेटा);


    # endif

    insert.c


    <टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

    // insert.c


    # शामिल "linkedlist.h"
    <कोड वर्ग = "टिप्पणियां"> // & quot; & quot; इसलिए प्रीप्रोसेसर
    // वर्तमान निर्देशिका में दिखता है और
    // मानक लाइब्रेरी फ़ाइलें बाद में।


    # include "stdlib.h >


    struct Node * create_node ( int data)

    {

    < कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड * अस्थायी = ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा" "> नोड *) <कोड वर्ग = "कार्य बोल्ड"> malloc <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कीवर्ड बोल्ड"> आकार <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड));

    <कोड वर्ग = "सादा"> अस्थायी- > डेटा = डेटा;

    <कोड वर्ग = "सादा"> अस्थायी- > अगला = शून्य;


    रिटर्न temp;

    }


    void b_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड "> int data)

    {

    <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड * new_node = create_node (डेटा);


    new_node- > अगला = * सिर;

    <कोड वर्ग = "सादा"> * सिर = new_node;

    }


    void n_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना <कोड वर्ग = "सादा"> नोड ** सिर, <कोड वर्ग = "रंग 1 बोल्ड "> int data, int pos)

    {

    if (* सिर == NULL) {

    <कोड वर्ग = "सादा"> b_insert (सिर, डेटा);

    <कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "कीवर्ड बोल्ड"> वापसी <कोड वर्ग = "सादा">;

    }


    स्ट्रक्चर <कोड क्लास =" प्लेन "> नोड * new_node = create_node (डेटा);


    स्ट्रक्चर Node * temp = * head;


    के लिए ( int i = 0; i "pos - 2;++ i)

    temp = अस्थायी- > अगला;


    new_node- > अगला = अस्थायी- > अगला;

    <कोड वर्ग = "सादा"> अस्थायी- > अगला = नया_नोड;

    <

Shop

Learn programming in R: courses

$

Best Python online courses for 2022

$

Best laptop for Fortnite

$

Best laptop for Excel

$

Best laptop for Solidworks

$

Best laptop for Roblox

$

Best computer for crypto mining

$

Best laptop for Sims 4

$

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

12 answers

NUMPYNUMPY

How to convert Nonetype to int or string?

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

12 answers


Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method