सी में सूचक वाक्यविन्यास: क्यों * केवल पहले चर पर लागू होता है?

Question

सी में निम्नलिखित घोषणा:

int* a, b; 

प्रकार int रूप a प्रकार int* के रूप में और b घोषित करेंगे। मैं इस जाल के बारे में अच्छी तरह से जानता हूं, लेकिन मैं क्या जानना चाहता हूं क्यों यह इस तरह से काम करता है। यह b को int* के रूप में भी घोषित नहीं करता है, क्योंकि अधिकांश लोग सहजता से अपेक्षा करते हैं? दूसरे शब्दों में, * क्यों प्रकार के बजाय परिवर्तनीय नाम पर लागू होता है?

सुनिश्चित करें कि आप इसे इस तरह लिख सकता है कि यह कैसे वास्तव में काम करता है के साथ और स्थायी:

int *a, b; 

हालांकि, मैं और सभी को मैं के संदर्भ में सोचने के लिए प्रकार का एक है "बात की है सूचकांक, ए के बजाय सूचक कुछ डेटा के लिए एक सूचक है और उस डेटा का प्रकार "int" है।

क्या यह सी के डिजाइनरों द्वारा बस एक बुरा निर्णय था या क्या इसका कोई अच्छा कारण है कि इसे इस तरह से पार्स किया गया है? मुझे यकीन है कि प्रश्न का उत्तर पहले दिया गया है, लेकिन मुझे खोज का उपयोग करके यह प्रतीत नहीं होता है।

Answer 1

The Development of the C Language पर एक वेब पेज है जो कहता है, "इन घोषणाओं का वाक्यविन्यास अवलोकन को दर्शाता है कि I, * pi, और ** ppi सभी अभिव्यक्ति में उपयोग किए जाने पर एक int प्रकार उत्पन्न करते हैं।" इस प्रश्न के बारे में बात करने वाले प्रासंगिक खंड को खोजने के लिए पृष्ठ पर उस वाक्य की खोज करें।

Answer 2

एक अतिरिक्त ऐतिहासिक कारण हो सकता है, लेकिन मैं हमेशा इसे इस तरह समझ लिया है:

एक घोषणा, एक प्रकार।

int a, b, c, d; 

फिर लाइन पर सब कुछ करना होगा एक पूर्णांक के रूप में अच्छी तरह से:

तो एक, ख, ग, और घ एक ही प्रकार के यहाँ होना चाहिए।

int a, *b, **c, ***d; 

4 पूर्णांकों:

1. एक
2. * ख
3. ** ग
4. *** घ

यह ऑपरेटर पूर्वता से संबंधित हो सकता, साथ ही, या यह अतीत में किसी बिंदु पर हो सकता है।

Answer 3

* वेरिएबल नाम संशोधित करता है, प्रकार विनिर्देशक नहीं। यह ज्यादातर * को पार्स किए जाने के कारण है। इन बयानों को लें:

char* x; 
char *x; 

ये कथन समकक्ष हैं। * ऑपरेटर को प्रकार विनिर्देशक और परिवर्तनीय नाम (यह इंफिक्स ऑपरेटर की तरह माना जाता है) के बीच होना चाहिए, लेकिन यह अंतरिक्ष के दोनों तरफ जा सकता है। यह देखते हुए घोषणा

int* a, b; 

b एक सूचक नहीं होगा, क्योंकि वहाँ कोई * यह करने के लिए आसन्न। * केवल इसके दोनों ओर वस्तुओं पर काम करता है।

इसके अलावा, इस बारे में सोचें: जब आप घोषणा int x; लिखते हैं, तो आप संकेत दे रहे हैं कि x एक पूर्णांक है। यदि y एक पूर्णांक के लिए एक सूचक है, तो *y एक पूर्णांक है। जब आप int *y; लिखते हैं, तो आप संकेत दे रहे हैं कि *y एक पूर्णांक है (जो आप चाहते हैं)। बयान char a, *b, ***c; में, आप संकेत दे रहे हैं कि परिवर्तनीय a, b का मानदंड मूल्य, और c का त्रिकोणीय-संदर्भित मान char का प्रकार है। इस तरह से घोषित चर तार ऑपरेटर (लगभग) का उपयोग dereferencing के साथ संगत बनाता है।

मैं मानता हूं कि यह लगभग दूसरी तरह से इसके लिए और अधिक समझ में आता है। इस जाल से बचने के लिए, मैंने खुद को एक लाइन पर पॉइंटर्स घोषित करने के लिए हमेशा एक नियम बना दिया।

Answer 4

सी घोषणाएं इस तरह लिखी गईं ताकि "घोषणा दर्पण का उपयोग किया जा सके"। यही कारण है कि आप इस तरह सरणियों की घोषणा:

int a[10]; 

आप थे बजाय नियम आप का प्रस्ताव है, जहां यह हमेशा

type identifier, identifier, identifier, ... ; 

है के लिए ... तो सरणियों तार्किक इस तरह की घोषणा करना होगा :

int[10] a; 

जो ठीक है, लेकिन दिखाई न दे कि कैसे आपa का उपयोग । , ध्यान दें कि यह कार्यों के लिए रखती है भी - हम इस तरह के कार्यों की घोषणा:

void foo(int a, char *b); 

बजाय

void(int a, char* b) foo; 

सामान्य में, "घोषणा दर्पण का उपयोग" नियम का मतलब केवल एक सेट याद करने के लिए है कि आप एसोसिएटिविटी नियमों का, जो *, [] और () दोनों ऑपरेटरों पर लागू होते हैं, जब आप मान का उपयोग कर रहे हैं, और *, [] और () जैसे घोषणाकर्ताओं में संबंधित टोकन लागू होते हैं।

---

कुछ आगे सोचा के बाद, मुझे लगता है कि यह भी उनका कहना है कि वर्तनी "सूचक int करने के लिए" के रूप में "int*" केवल "घोषणा दर्पण का उपयोग" वैसे भी का परिणाम है लायक है। यदि आप घोषणा की एक और शैली का उपयोग करने जा रहे थे, तो संभवत: "सूचकांक int" के रूप में "&int" या "@int" जैसी पूरी तरह से अलग करने के लिए अधिक समझदारी होगी।

Answer 5

क्योंकि अगर बयान

int* a, b; 

भी b सूचक के रूप में घोषित करने के लिए थे, तो आप एक ही लाइन पर

int* a; 
int b; 

घोषित करने के लिए कोई रास्ता नहीं होगा।

दूसरी ओर, आप आप क्या चाहते हैं पाने के लिए

int*a, *b; 

कर सकते हैं।

इस बारे में सोचें: जिस तरह से यह अभी भी यह करने का सबसे संक्षिप्त और अभी तक अनोखा तरीका है।

int x[20], y; 
int (*fp)(), z; 

इन उदाहरणों में, यह बहुत ज्यादा स्पष्ट है कि संशोधक केवल में से एक को प्रभावित कर रहे महसूस करता है: यह ज्यादातर के बारे में :)

Answer 6

मुझे लगता है यह प्रकार संशोधकों के पूर्ण घोषणा वाक्य रचना से संबंधित है क्या सी है घोषणाएं एक अनुमान यह है कि एक बार के & आर ने इस तरह से संशोधकों को डिजाइन करने का फैसला किया, यह संशोधित करने के लिए "सही" महसूस किया गया है कि संशोधक केवल एक घोषणा को प्रभावित करते हैं।

एक तरफ ध्यान दें पर, मैं बस अपने आप को घोषणा प्रति एक चर करने के लिए सीमित की सिफारिश करेंगे:

int *x; 
int y; 

Answer 7

मैं केवल अनुमान लगा सकते हैं क्यों एक बनाने के लिए हर चर नाम एक लाइन पर उल्लेख के लिए * दोहराने के लिए होता है उन सभी पॉइंटर्स। शायद यह भाषा स्थिरता के फैसले के कारण है?

int foo() { ... } 

यह भी मान लें कि आप इस समारोह के लिए दो समारोह संकेत घोषित करने के लिए चाहते हैं::

---

मान लेते हैं तो आप एक समारोह foo घोषित इस प्रकार करते हैं: मुझे एक उदाहरण के साथ इस उदाहरण देकर स्पष्ट करते

int (*fooptr1, fooptr2)(); 
// this doesn't work; and even if it did, what would the syntax possibly 
// look like to initializing them to function foo? 
// int (*fooptr1 = foo, fooptr2 = foo)() ? 

int (*fooptr1)() = foo, (*fooptr2)() = foo; 
// this works. 

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

---

अब, शायद यह सोचा गया है, अगर वहाँ मामलों में जहां प्रकार घोषणा सभी चर के लिए बार-बार हो गया है कर रहे हैं, हो सकता है यह सिर्फ सामान्य स्थिति में होना चाहिए।

(यह न भूलें कि मैं सिर्फ यहाँ अनुमान लगा रहा हूँ।)

Answer 8

घोषणा पर विचार करें:

int *a[10]; 
int (*b)[10]; 

पहले पूर्णांकों के लिए दस संकेत की एक सरणी है, दूसरा के लिए सूचक है दस पूर्णांक की एक सरणी।

अब, यदि * प्रकार की घोषणा से जुड़ा हुआ था, तो यह उनके बीच एक संश्लेषण रखने के लिए सिंथेटिक रूप से मान्य नहीं होगा। तो आपको दो रूपों के बीच अंतर करने के लिए एक और तरीका खोजना होगा।