c - what - हमें सी में इतनी बार एक स्ट्रिप टाइप क्यों करना चाहिए?




what is structure in c in hindi (10)

'सी' प्रोग्रामिंग भाषा में कीवर्ड 'typedef' का उपयोग किसी ऑब्जेक्ट (स्ट्रक्चर, सरणी, फ़ंक्शन..नम प्रकार) के लिए एक नया नाम घोषित करने के लिए किया जाता है। उदाहरण के लिए मैं 'स्ट्रक्चर-एस' का उपयोग करूंगा। 'सी' में हम अक्सर 'मुख्य' फ़ंक्शन के बाहर 'संरचना' घोषित करते हैं। उदाहरण के लिए:

struct complex{ int real_part, img_part }COMPLEX;

main(){

 struct KOMPLEKS number; // number type is now a struct type
 number.real_part = 3;
 number.img_part = -1;
 printf("Number: %d.%d i \n",number.real_part, number.img_part);

}

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

typedef struct complex{int real_part, img_part; }COMPLEX;
//now COMPLEX is the new name for this structure and if I want to use it without
// a keyword like in the first example 'struct complex number'.

main(){

COMPLEX number; // number is now the same type as in the first example
number.real_part = 1;
number.img)part = 5;
printf("%d %d \n", number.real_part, number.img_part);

}

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

मैंने कई कार्यक्रमों को देखा है जिनमें नीचे दिए गए संरचनाएं शामिल हैं

typedef struct 
{
    int i;
    char k;
} elem;

elem user;

इतनी बार इसकी आवश्यकता क्यों है? कोई विशिष्ट कारण या लागू क्षेत्र?


typedef डेटा संरचनाओं का सह-निर्भर सेट प्रदान नहीं करेगा। यह आप टाइपडीएफ के साथ नहीं कर सकते हैं:

struct bar;
struct foo;

struct foo {
    struct bar *b;
};

struct bar {
    struct foo *f;
};

बेशक आप हमेशा जोड़ सकते हैं:

typedef struct foo foo_t;
typedef struct bar bar_t;

उस बिंदु का बिल्कुल क्या मतलब है?


इस समस्या से हमेशा टाइपपीफ enums और structs के परिणाम के लिए एक और अच्छा कारण:

enum EnumDef
{
  FIRST_ITEM,
  SECOND_ITEM
};

struct StructDef
{
  enum EnuumDef MyEnum;
  unsigned int MyVar;
} MyStruct;

संरचना में EnumDef में टाइपो नोटिस (Enu u mDef)? यह त्रुटि (या चेतावनी) के बिना संकलित करता है और (सी मानक की शाब्दिक व्याख्या के आधार पर) सही है। समस्या यह है कि मैंने अभी अपनी संरचना के भीतर एक नई (खाली) गणना परिभाषा बनाई है। मैं पिछले परिभाषा EnumDef का उपयोग कर (इरादे के रूप में) नहीं हूँ।

एक टाइपडेफ के समान प्रकार के टाइपो के परिणामस्वरूप अज्ञात प्रकार का उपयोग करने के लिए एक कंपाइलर त्रुटियां होती हैं:

typedef 
{
  FIRST_ITEM,
  SECOND_ITEM
} EnumDef;

typedef struct
{
  EnuumDef MyEnum; /* compiler error (unknown type) */
  unsigned int MyVar;
} StructDef;
StrructDef MyStruct; /* compiler error (unknown type) */

मैं हमेशा typedef'ing structs और गणनाओं की वकालत करता हूं।

न केवल कुछ टाइपिंग को सहेजने के लिए (कोई इरादा नहीं है;)), लेकिन क्योंकि यह सुरक्षित है।


ए> डेटा टाइप के लिए अधिक सार्थक समानार्थी बनाने की अनुमति देकर एक प्रोग्राम के अर्थ और दस्तावेज़ीकरण में एक टाइपडेफ एड्स। इसके अलावा, वे पोर्टेबिलिटी समस्याओं (के एंड आर, पीजी 147, सी प्रोग लैंग) के खिलाफ एक प्रोग्राम पैरामीटर बनाने में मदद करते हैं।

बी> एक संरचना एक प्रकार परिभाषित करता है । स्ट्रक्चर एक इकाई के रूप में हैंडलिंग (के एंड आर, पीजी 127, सी प्रोग लैंग।) की सुविधा के लिए वर्रों के संग्रह के सुविधाजनक समूह को अनुमति देता है।

सी> उपरोक्त में एक स्ट्रिप टाइपिंग की व्याख्या की गई है।

डी> मेरे लिए, structs कस्टम प्रकार या कंटेनर या संग्रह या नामस्थान या जटिल प्रकार हैं, जबकि एक टाइपडीएफ सिर्फ अधिक प्रचलित नाम बनाने का साधन है।


जिस नाम से आप (वैकल्पिक रूप से) संरचना को टैग नाम कहते हैं, जैसा कि नोट किया गया है, स्वयं में एक प्रकार नहीं है। प्रकार प्राप्त करने के लिए संरचना उपसर्ग की आवश्यकता है।

जीटीके + एक तरफ, मुझे यकीन नहीं है कि टैगनाम का उपयोग स्ट्रक्चर प्रकार के लिए टाइपिफ़ के रूप में सामान्य रूप से किया जाता है, इसलिए सी ++ में पहचाना जाता है और आप स्ट्रक्चर कीवर्ड को छोड़ सकते हैं और टैगनाम को टाइप नाम के रूप में भी इस्तेमाल कर सकते हैं:


    struct MyStruct
    {
      int i;
    };

    // The following is legal in C++:
    MyStruct obj;
    obj.i = 7;


जैसा कि ग्रेग हेगिल ने कहा था, टाइपपीफ का मतलब है कि अब आपको जगह पर struct लिखनी पड़ेगी। यह न केवल कीस्ट्रोक बचाता है, यह कोड क्लीनर भी बना सकता है क्योंकि यह एक स्मिडजेन को अधिक अमूर्तता प्रदान करता है।

सामान की तरह

typedef struct {
  int x, y;
} Point;

Point point_new(int x, int y)
{
  Point a;
  a.x = x;
  a.y = y;
  return a;
}

जब आपको जगह पर "संरचना" कीवर्ड देखने की आवश्यकता नहीं होती है तो क्लीनर बन जाता है, ऐसा लगता है कि वास्तव में आपकी भाषा में "प्वाइंट" नामक एक प्रकार है। जो, typedef बाद, मुझे लगता है कि मामला है।

यह भी ध्यान रखें कि जब आपका उदाहरण (और मेरा) struct नामकरण छोड़ देता है, वास्तव में यह नामकरण भी उपयोगी होता है जब आप एक अपारदर्शी प्रकार प्रदान करना चाहते हैं। फिर आपके पास हेडर में इस तरह का कोड होगा, उदाहरण के लिए:

typedef struct Point Point;

Point * point_new(int x, int y);

और फिर कार्यान्वयन फ़ाइल में struct घोषणा प्रदान करें:

struct Point
{
  int x, y;
};

Point * point_new(int x, int y)
{
  Point *p;
  if((p = malloc(sizeof *p)) != NULL)
  {
    p->x = x;
    p->y = y;
  }
  return p;
}

इस बाद के मामले में, आप प्वाइंट को मूल्य से वापस नहीं कर सकते हैं, क्योंकि इसकी घोषणा हेडर फ़ाइल के उपयोगकर्ताओं से छिपी हुई है। उदाहरण के लिए, यह GTK+ में व्यापक रूप से उपयोग की जाने वाली तकनीक है।

अद्यतन नोट करें कि अत्यधिक सी परियोजनाएं भी हैं जहां typedef को छिपाने के लिए typedef का उपयोग एक बुरा विचार माना जाता है, लिनक्स कर्नेल शायद सबसे प्रसिद्ध परियोजना है। लिनस के क्रोधित शब्दों के लिए लिनक्स कर्नेल कोडिंग स्टाइल दस्तावेज़ का अध्याय 5 देखें। :) मेरा मुद्दा यह है कि सवाल में "चाहिए" शायद पत्थर में सेट नहीं है, सब के बाद।


मुझे नहीं लगता कि टाइपपीफ के साथ आगे की घोषणा भी संभव है। संरचना, एनम और यूनियन का उपयोग आगे की घोषणाओं के लिए अनुमति देता है जब निर्भरता (जानता है) द्विपक्षीय है।

शैली: सी ++ में टाइपपीफ का उपयोग काफी समझ में आता है। टेम्पलेट्स से निपटने के दौरान यह लगभग आवश्यक हो सकता है जिसके लिए एकाधिक और / या परिवर्तनीय पैरामीटर की आवश्यकता होती है। टाइपपीफ नामकरण को सीधे रखने में मदद करता है।

सी प्रोग्रामिंग भाषा में ऐसा नहीं है। टाइपपीफ का उपयोग अक्सर डेटा संरचना उपयोग को खराब करने के लिए कोई उद्देश्य नहीं देता है। चूंकि केवल {स्ट्रक्चर (6), एनम (4), यूनियन (5)} कीस्ट्रोक की संख्या डेटा प्रकार घोषित करने के लिए उपयोग की जाती है, वहां संरचना के एलियासिंग के लिए लगभग कोई उपयोग नहीं होता है। क्या वह डेटा एक संघ या संरचना है? सीधे आगे गैर-टाइपडेफ़ेड घोषणा का उपयोग करने से आप तुरंत यह जान सकते हैं कि यह किस प्रकार है।

ध्यान दें कि लिनक्स को इस एलियासिंग बकवास टाइपिफ के सख्त टालने के साथ कैसे लिखा जाता है। नतीजा एक न्यूनतम और साफ शैली है।


यह आश्चर्यजनक है कि कितने लोगों को यह गलत लगता है। कृपया सी में typedef structs नहीं है, यह वैश्विक नामस्थान को अनिवार्य रूप से प्रदूषित करता है जो आम तौर पर बड़े सी प्रोग्रामों में बहुत प्रदूषित है।

साथ ही, टैग नाम के बिना typedef'd structs हेडर फ़ाइलों के बीच संबंधों को ऑर्डर करने की आवश्यकताहीन लगाव का एक प्रमुख कारण हैं।

विचार करें:

#ifndef FOO_H
#define FOO_H 1

#define FOO_DEF (0xDEADBABE)

struct bar; /* forward declaration, defined in bar.h*/

struct foo {
  struct bar *bar;
};

#endif

इस तरह की परिभाषा के साथ, टाइपपीफ का उपयोग नहीं करते हुए, एक compiland इकाई के लिए FOO_DEF परिभाषा प्राप्त करने के लिए foo.h शामिल करना संभव है। यदि यह foo संरचना के 'बार' सदस्य को कम करने का प्रयास नहीं करता है तो "bar.h" फ़ाइल को शामिल करने की आवश्यकता नहीं होगी।

साथ ही, चूंकि नेमस्पेस टैग नामों और सदस्य नामों के बीच अलग हैं, इसलिए बहुत पठनीय कोड लिखना संभव है जैसे कि:

struct foo *foo;

printf("foo->bar = %p", foo->bar);

चूंकि नेमस्पेस अलग हैं, इसलिए उनके स्ट्रक्चर टैग नाम के साथ संयोग नामकरण चर में कोई संघर्ष नहीं है।

अगर मुझे अपना कोड बनाए रखना है, तो मैं आपके typedef'd structs को हटा दूंगा।


सी 99 टाइपिफ़ में बदल जाता है। यह पुराना है, लेकिन बहुत से टूल्स (एला हैक्रैंक) सी 99 का शुद्ध सी कार्यान्वयन के रूप में उपयोग करते हैं। और typedef वहाँ आवश्यक है।

मैं यह नहीं कह रहा कि उन्हें बदलना चाहिए (शायद दो सी विकल्प हैं) यदि आवश्यकता बदल गई है, तो हम साइट पर साक्षात्कार के लिए अध्ययन करने वाले लोग एसओएल होंगे।


सी, भाषा में, संरचना / संघ / enum सी भाषा प्रीप्रोसेसर द्वारा संसाधित मैक्रो निर्देश हैं (प्रीप्रोसेसर के साथ गलती न करें जो "# शामिल" और अन्य का इलाज करती है)

इसलिए :

struct a
{
   int i;
};

struct b
{
   struct a;
   int i;
   int j;
};

संरचना बी इस तरह कुछ के रूप में खर्च किया गया है:

struct b
{
    struct a
    {
        int i;
    };
    int i;
    int j;
}

और इसलिए, संकलन समय पर यह ढेर पर विकसित होता है जैसे: बी: int ai int i int j

यही कारण है कि यह आत्मनिर्भर structs, सी प्रीप्रोसेसर दौर एक व्याख्यान लूप में भिन्न है जो समाप्त नहीं कर सकता है।

टाइपिफ़ टाइप प्रकार विनिर्देशक है, जिसका अर्थ केवल सी संकलक प्रक्रिया है और ऐसा कर सकता है जैसे वह एंबलर कोड कार्यान्वयन को अनुकूलित करने के लिए चाहता है। यह प्रैप्रोसेसर जैसे स्ट्रक्डर्स के साथ टाइप पैरा के सदस्य को भी खर्च नहीं करता है बल्कि अधिक जटिल संदर्भ निर्माण एल्गोरिदम का उपयोग करता है, इसलिए निर्माण जैसे:

typedef struct a A; //anticipated declaration for member declaration

typedef struct a //Implemented declaration
{
    A* b; // member declaration
}A;

अनुमति है और पूरी तरह कार्यात्मक है। यह कार्यान्वयन कंपाइलर प्रकार रूपांतरण तक पहुंच प्रदान करता है और कुछ बगिंग प्रभावों को हटा देता है जब निष्पादन थ्रेड प्रारंभिक कार्यों के अनुप्रयोग फ़ील्ड को छोड़ देता है।

इसका मतलब यह है कि सी टाइपिफ में अकेले structs की तुलना में सी ++ वर्ग के करीब हैं।





typedef