पास्कल और सी की तुलना

कंप्यूटर प्रोग्रामिंग भाषा C और पास्कल की उत्पत्ति, प्रभाव और उद्देश्य समान होते हैं। दोनों का उपयोग उनके जीवनकाल के आरंभ में अपने स्वयं के संकलकों को डिजाइन (और संकलित) करने के लिए किया जाता था। मूल पास्कल परिभाषा 1969 में प्रकाशित हुई और 1970 में इसका पहला संकलन हुआ। C का पहला संस्करण 1972 में प्रकाशित हुआ था।

दोनों ऐल्गॉल भाषा श्रृंखला के वंशज हैं। ऐल्गॉल ने संरचित प्रोग्रामिंग के प्रोग्रामिंग भाषा को प्रारंभ किया, जहां प्रोग्राम एकल प्रविष्टि और एकल निकास संरचनाओं जैसे कि, अगर, जबकि, फॉर और केस से निर्मित होते हैं। पास्कल सीधे ऐल्गॉल डब्लू से उत्पन्न हुआ है, जबकि इसने ऐल्गॉल 68 के साथ कुछ नए विचारों को साझा किया है। C भाषा अप्रत्यक्ष रूप से ऐल्गॉल से संबंधित है, मूल रूप से B, बीसीपीएल और सीपीएल, और बाद में ऐल्गॉल 68 के माध्यम से (उदाहरण के लिए संरचना और यूनियन के स्थितियों मे) और पास्कल भी (उदाहरण के लिए गणना स्थिरांक, टाइपपीफ और बूलियन के स्थिति में) के माध्यम से। ) कुछ पास्कल उपभाषा में C के विशेषता भी सम्मलित हैं।

यहां प्रलेखित भाषाएं निकोलस विर्थ का पास्कल, जिन्हें 1982 में आईएसओ 7185 के रूप में मानकीकृत किया गया था, और ब्रायन कर्निघन और डेनिस रिची की सी, जैसा कि 1989 में मानकीकृत किया गया था।इसका कारण यह है कि ये दोनों संस्करण भाषा के परिपक्व संस्करण का प्रतिनिधित्व करते हैं, और यह भी कि वे समय में तुलनात्मक रूप से समीप हैं। एएनएसआई सी और सी99 (बाद के सी मानक) की विशेषताएं, और पास्कल (टर्बो पास्कल, फ़्री पास्कल) के बाद के कार्यान्वयन की विशेषताओं को उनके द्वारा प्रदान की गई मजबूती और कार्यक्षमता में सुधार के अतिरिक्त तुलना में सम्मलित नहीं किया गया है।

वाक्य-विन्यास

वाक्यात्मक रूप से, पास्कल C वाक्य - विन्यास की तुलना में बहुत अधिक ऐल्गॉल जैसा है। जहाँ C विराम चिह्नों का उपयोग करता है, वहाँ अंग्रेजी कीवर्ड बनाए रखे जाते हैं पास्कल के पास and, or, और modहै जहाँ C, &&, ||, और % उपयोग करता है। चूँकि, (सरल) घोषणाओं के बारे में पास्कल की तुलना में C अधिक ऐल्गॉल-जैसा है, प्रकार-नाम चर-नाम वाक्यविन्यास को बनाए रखता है। उदाहरण के लिए, C किसी कार्य का बाहरी ब्लॉक ही नहीं होता , जबकि किसी भी ब्लॉक की प्रारम्भिक घोषणाएं भी स्वीकार कर सकता है।

अर्धविराम का उपयोग

एक और, अधिक सूक्ष्म अंतर अर्धविराम की भूमिका होती है। पास्कल में, अर्धविराम मिश्रित कथन के भीतर अलग-अलग कथनों को अलग करते हैं; इसके अतिरिक्त C में, वे कथन को समाप्त कर देते हैं। C में, वे वाक्यात्मक रूप से भी कथन का हिस्सा होते हैं (एक अभिव्यक्ति को एक कथन में बदलना)। अंतर मुख्यतः दो स्थितियों में प्रकट होता है:

• पास्कल में अर्धविराम else पहले कभी नहीं हो सकता else, पहले कभी नहीं हो सकता है, जबकि C में, यह अनिवार्य है, जब तक कि ब्लॉक कथन का उपयोग नहीं किया जाता है
• अंत से पहलेend या until के बाद अर्धविराम लगाना आवश्यक नहीं है

अंत से पहले अंतिम पंक्ति पर एक अतिरिक्त अर्धविराम लगाया जा सकता है, जिससे औपचारिक रूप से रिक्त कथन डाला जा सकता है।

टिप्पणियाँ

पारंपरिक C में, केवल हैं /*block comments } */ होती हैं।यह केवल मिडलेटपास्कल जैसी कुछ पास्कल उपभाषा द्वारा समर्थित है।

पारंपरिक पास्कल में,{ block comments } और (* block comments *)आधुनिक पास्कल, जैसे वस्तु पास्कल (डेल्फी, एफपीसी), साथ ही साथ आधुनिक C कार्यान्वयन C++ शैली टिप्पणियों की अनुमति देते हैं // line comments

पहचानकर्ता और कीवर्ड

सी और पास्कल ऊपरी और निचले स्थितियों की अपनी व्याख्या में भिन्न हैं। C स्थिति संवेदनशील है जबकि पास्कल नहीं होता है, इस प्रकारMyLabel और mylabel C में अलग-अलग नाम हैं किन्तु पास्कल में समान हैं। दोनों भाषाओं में, पहचानकर्ताओं में अक्षर और अंक सम्मलित होते हैं, इस नियम के साथ कि पहला वर्ण अंक नहीं हो सकता है। C में, अंडरस्कोर एक अक्षर के रूप में गिना जाता है, इसलिए abc भी एक वैध नाम है। अग्रणी अंडरस्कोर वाले नाम अधिकांशतः C में विशेष प्रणाली पहचानकर्ताओं को अलग करने के लिए उपयोग किए जाते हैं।

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

परिभाषाएं, घोषणाएं और ब्लॉक

पास्कल में, प्रक्रिया परिभाषाएँ कीवर्ड प्रक्रिया या फलन से प्रारंभ होती हैं और और टाइप परिभाषाएँ प्रकार से प्रारंभ होती हैं। सी में, फलन परिभाषाएँ वाक्य-विन्यास संदर्भ द्वारा निर्धारित की जाती हैं जबकि परिभाषाएं कीवर्ड typedef. दोनों भाषाएँ जटिल प्रकारों की परिभाषाओं के लिए कीवर्ड और विराम चिह्नों के मिश्रण का उपयोग करती हैं; उदाहरण के लिए, सरणियों को पास्कल में कीवर्ड सरणी और सी में विराम चिह्न द्वारा परिभाषित किया जाता है, जबकि गणनाओं को सी में कीवर्ड एनम द्वारा किन्तु पास्कल में विराम चिह्न द्वारा परिभाषित किया जाता है।

पास्कल फलन में, प्रारंभ और अंत कथनों के एक ब्लॉक (उचित) को परिसीमित करते हैं, जबकि C फलन वैकल्पिक रूप से घोषणाओं से पहले कथनों के एक ब्लॉक को परिसीमित करने के लिए "{" और "}" का उपयोग करते हैं। C (C99 से पहले) सख्ती से परिभाषित करता है कि किसी भी घोषणा को विशेष ब्लॉक के भीतर कथनों से पहले होना चाहिए, किन्तु ब्लॉक को ब्लॉक के भीतर प्रदर्शित होने की अनुमति देता है, जो कि इससे बचने की एक प्रणाली है। पास्कल इस बात पर सख्त है कि घोषणाएँ कथनों से पहले होनी चाहिए, किन्तु प्रकारों और कार्यों की परिभाषाओं को - न केवल परिवर्तनीय घोषणाओं को - गहराई के किसी भी स्तर तक फलन परिभाषाओं द्वारा समाहित करने की अनुमति देता है।

कार्यान्वयन

दोनों भाषाओं के व्याकरण समान आकार होता हैं। एक कार्यान्वयन परिप्रेक्ष्य से दो भाषाओं के बीच मुख्य अंतर यह है कि सी को पदच्छेद करने के लिए प्रकारों के लिए प्रतीक तालिका तक पहुंच होना आवश्यक है, जबकि पास्कल में केवल एक ही ऐसा निर्माण, असाइनमेंट होता है। उदाहरण के लिए, C खंड X * Y; Y की एक ऐसी वस्तु होने की घोषणा हो सकती है जिसका प्रकार X का सूचक है, या एक कथन-अभिव्यक्ति जो X और Y को गुणा करती है। इसके विपरीत, संबंधित पास्कल खंड var Y:^X;स्वाभाविक रूप से असंदिग्ध है; सही पार्सिंग के लिए प्रतीक तालिका की आवश्यकता नहीं होती है।

साधारण प्रकार

पूर्णांक

पास्कल को सभी परिवर्त्य और फलन घोषणाओं को उनके प्रकार को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता होती है। पारंपरिक सी में, अधिकांश संदर्भों में एक प्रकार का नाम छोड़ा जा सकता है और डिफ़ॉल्ट प्रकार int (जो पास्कल मेंपूर्णांकसे मेल खाता है) को तब अंतर्निहित रूप से मान लिया जाता है (चूँकि , इस तरह की चूक को खराब माना जाता है और अधिकांशतः चेतावनियों द्वारा चिह्नित किया जाता है)।

C long, short, signed, unsigned, आदि जैसे संशोधक का उपयोग करके पूर्णांकों के लिए विभिन्न आकारों और हस्ताक्षरित और अहस्ताक्षरित विधि को समायोजित करता है। परिणामी पूर्णांक प्रकार का त्रुटिहीन अर्थ यंत्राश्रित होता है, जिसकी गारंटी दी जा सकती है वह यह है कि long int से छोटा नहीं है int और int से छोटा नहीं है short int. चूँकि, C मानक में, प्रकारों के कम से कम न्यूनतम आकार निर्दिष्ट किए गए हैं जो char को एक बाइट होने के लिए और intको कम से कम दो बाइट्स होने की गारंटी देता है।

उपश्रेणियाँ

पास्कल में, एक समान अंत पूर्णांक की उपश्रेणी घोषित करके एक समान अंत किया जाता है ( तब एक संकलक घोषित करके अस्थिर मात्रा में संचयन करने का चयन कर सकता है):

type a = 1..100;
     b = -20..20;
     c = 0..100000;

यह उपश्रेणी सुविधा C द्वारा समर्थित नहीं है.

सी और पास्कल के बीच एक प्रमुख, यदि सूक्ष्म हो, अंतर यह है कि वे पूर्णांक संचालन को कैसे बढ़ावा देते हैं। पास्कल में, एक संचालन के परिणाम को सभी पूर्णांक/उपश्रेणी प्रकारों के लिए परिभाषित किया जाता है, यदि मध्यवर्ती परिणाम एक पूर्णांक में अनुरूप न हों। परिणाम केवल तभी अपरिभाषित होता है जब वह असाइनमेंट के बाईं ओर पूर्णांक/उपश्रेणी में अनुरूप नहीं होता है। इसका मतलब पूर्णांक प्रकारों की सीमा पर एक कृत्रिम प्रतिबंध हो सकता है, या मध्यवर्ती परिणामों को संभालने के लिए धीमी निष्पादन की आवश्यकता हो सकती है: चूँकि, संकलक अधिक कुशल कोड का उत्पादन करने के लिए प्रतिबंधित उपश्रेणियों का लाभ उठा सकता है।

सी में, ऑपरेंड को पहले आवश्यक परिणाम के आकार में पदोन्नत किया जाना चाहिए:मध्यवर्ती परिणाम अपरिभाषित होते हैं यदि वे प्रचारित ऑपरेंड की सीमा के अनुरूप नहीं होते हैं। यदि आवश्यक परिणाम की सीमा ऑपरेंड की सीमा से अधिक है, तो यह सामान्य एक अच्छे अनुकूलन कंपाइलर से भी धीमी गति से अक्षम कोड उत्पन्न करता है। चूँकि, सीमा से बाहर के मध्यवर्ती परिणामों को संभालने के लिए C कंपाइलर की कभी भी आवश्यकता या अपेक्षा नहीं की जाती है: यह सुनिश्चित करने के लिए प्रोग्रामर की उत्तरदायित्व है कि सभी मध्यवर्ती परिणाम ऑपरेंड रेंज में अनुरूप होता है।

सी के साथ-साथ स्माल-सी अन्य का पूर्व-मानक कार्यान्वयन होते है। पूर्णांक और सूचक (कंप्यूटर प्रोग्रामिंग) प्रकारों को अपेक्षाकृत स्वतंत्र रूप से मिश्रित होने की अनुमति दी गई।

वर्ण प्रकार

C में वर्ण प्रकार char जो एक प्रकार का पूर्णांक है जो short int, . से अधिक लंबा नहीं है। इसलिए 'x'+1 इसलिए पूरी तरह से सैद्धांतीक होती हैं, जैसे int i='i'; और char c=74;.

char (एक बाइट) की यह पूर्णांक प्रकृति स्पष्ट रूप से घोषणा द्वारा चित्रित की गई है

unsigned char uc = 255;  /* common limit */
signed char sc = -128;   /* common negative limit */

क्या char डिफ़ॉल्ट रूप से signed या unsigned माना जाना चाहिए, यह कार्यान्वयन पर निर्भर है।

पास्कल में, वर्ण और पूर्णांक भिन्न प्रकार होते हैं। अन्तर्निहित संकलनकर्ता कार्य करता है ord() और chr() का उपयोग एकल वर्णों को उपयोग में आने वाले वर्ण सेट के संबंधित पूर्णांक मान पर टाइपकास्ट करने के लिए किया जा सकता है, और इसके विपरीत उदा. एएससीआईआई संप्रतीक समुच्चय का उपयोग करने वाले प्रणाली पर ord('1') = 49 और chr(9) एक टैब संप्रतीक समुच्चय होता है।

बूलियन प्रकार

पास्कल में, बूलियन डेटाटाइप एक प्रगणित प्रकार है। बूलियन के संभावित मान गलत और सत्य हैं, जिसका क्रमिक मान गलत = 0 और सत्य = 1 के क्रमिक मूल्य के साथ होता है। पूर्णांक में रूपांतरण के लिए, ord का उपयोग किया जाता है:

i := ord(b);

पूर्णांक से बूलियन के लिए कोई मानक कार्य नहीं है, चूँकि , व्यवहार में रूपांतरण सरल है:

b := i <> 0;

सी में बाइनरी वैल्यू संबंधपरक संकारक (<,>, ==, !=, <=,>=) होता हैं, जिन्हें इस अर्थ में बूलियन माना जा सकता है कि वे सदैव परिणाम देते हैं जो या तो शून्य या एक होते हैं। जैसा कि सभी परीक्षण (&&, ||,?:, 'अगर', 'जबकि', आदि) शून्य ​​द्वारा किए जाते हैं, 'गलत' को शून्य द्वारा दर्शाया जाता है, जबकि 'सत्य' को किसी अन्य मान द्वारा दर्शाया जाता है।

बिटवाइज़ संचालन

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

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

पास्कल:

Status := Status + [StickyFlag];
Status := Status - [StickyFlag];
if (StickyFlag in Status) then ...

(* Alternatively, using bitwise operators: *)
Status := Status or StickyFlag;
Status := Status and not StickyFlag;
if StickyFlag and Status = StickyFlag then ...

C:

Status |= StickyFlag;
Status &= ~StickyFlag;
if (Status & StickyFlag) { ...

यद्यपि पूर्णांकों पर बिट संचालन और सेटों पर संचालन को समान माना जा सकता है यदि सेट बिट्स का उपयोग करके कार्यान्वित किए जाते हैं, तो उनके उपयोग के बीच कोई सीधा समानांतर नहीं है जब तक कि पूर्णांक और सेट के बीच एक गैर-मानक रूपांतरण संभव न हो सके।

कार्यान्वयन पर एक टिप्पणी

अभिव्यक्ति मूल्यांकन के समय , और दोनों भाषाओं में, एक बूलियन मान आंतरिक रूप से यांत्रिक आधार पर एक बिट, एक बाइट, एक पूर्ण यांत्रिक शब्द , उत्पन्न कोड में एक स्थिति, या स्थिति रजिस्टर में एक स्थिति कोड के रूप में संग्रहीत किया जा सकता है। संकलक, और स्थिति; ये कारक सामान्यतः संकलित भाषा से अधिक महत्वपूर्ण होते हैं।

फ़्लोटिंग पॉइंट प्रकार

सी में पास्कल की तुलना में फ़्लोटिंग पॉइंट एक प्रकार का कम सख्त मॉडल है। सी में, पूर्णांकों को अंतर्निहित रूप से फ़्लोटिंग पॉइंट संख्याओं में परिवर्तित किया जा सकता है, और इसके विपरीत (चूँकि संभावित त्रुटिहीन चेतावनियों द्वारा चिह्नित किया जा सकता है)। पास्कल में, पूर्णांकों को अंतर्निहित रूप से वास्तविक में परिवर्तित किया जा सकता है, किन्तु वास्तविक को पूर्णांक में परिवर्तित करना (जहाँ जानकारी लुप्त सकती है) स्पष्ट रूप से trunc() और round(), के माध्यम से किया जाना चाहिए, जो क्रमशः अंश को छोटा या गोल करते हैं।

गणना के प्रकार

C सी और पास्कल दोनों में गणना प्रकार सम्मलित होती हैं। पास्कल उदाहरण:

type
  color = (red, green, blue);
var
  a: color;

ए सी उदाहरण:

enum color {red, green, blue};
enum color a;

चूँकि दोनों भाषाओं में प्रकारों का व्यवहार बहुत भिन्न है। में, red केवल 0 का पर्याय बन जाता है, green 1 के लिए, blue 2 के लिए, और कुछ भी इस सीमा के बाहर के मान को परिवर्त्य a को निर्दिष्ट करने से नहीं रोकता है। इसके अतिरिक्त, संचालन जैसे a = a + 1; पास्कल में सर्वथा निषिद्ध हैं; इसके अतिरिक्त a := succ(a);का उपयोग करेंगे। C में, एनम को स्वतंत्र रूप से और ints से परिवर्तित किया जा सकता है, किन्तु पास्कल में, फलन ord() का उपयोग प्रगणित प्रकारों से पूर्णांक में परिवर्तित करने के लिए किया जाना चाहिए, विपरीत रूपांतरण में green मान वापसी करने के लिएa := color(1)जैसे टाइपकास्ट संचालन का उपयोग किया जाना चाहिए।

संरचित प्रकार

सरणी प्रकार

सी और पास्कल दोनों अन्य सरणियों सहित अन्य जटिल प्रकार के सरणियों की अनुमति देते हैं। चूँकि, वहाँ भाषाओं के बीच समानता समाप्त हो जाती है। C सरणियों को केवल आधार प्रकार और तत्वों की संख्या द्वारा परिभाषित किया जाता है:

int a[SIZE];

और सदैव 0 से SIZE−1 (अर्थात मॉड्यूलो SIZE) तक अनुक्रमित होते हैं।

पास्कल में, सूचकांकों की श्रेणी को अधिकांशतः एक उपश्रेणी द्वारा निर्दिष्ट किया जाता है (जैसा कि ऊपर सरल प्रकार से प्रस्तुत किया गया है)। के दस तत्व होते है

var a : array[0..9] of integer;

0..9 द्वारा अनुक्रमित किया जाएगा (जैसा कि इस स्थितियों में C में है)। सारणी सूचकांक कोई भी क्रमिक डेटा प्रकार हो सकता है, चूँकि , केवल श्रेणियाँ नहींहोती :

type
   TColor = (red, green, blue);       (* enumeration *)
   RGB = array[TColor] of 0..255;

var picture : array[1..640, 1..480] of RGB

var palette : array[byte, 0..2] of byte

n (>1) वर्णों वाले श्रृंखला को श्रेणी 1..n के साथ संकुलित किए गए सरणियों के रूप में परिभाषित किया गया है।

सरणियाँ और संकेत

सी अभिव्यक्तियों में, एक सरणी का प्रतिनिधित्व करने वाले पहचानकर्ता को सरणी के पहले तत्व के लिए एक स्थिर सूचक के रूप में माना जाता है, इस प्रकार, घोषणाओं को int a[10] और int *p; दी जाती हैं; समनुदेशन p = a मान्य है और p और a को एक ही सरणी की ओर इंगित करता है। चूँकि पहचानकर्ता a एक स्थिर पते का प्रतिनिधित्व करता है, चूँकि, a = p मान्य नहीं है।

जबकि C में सरणियाँ निश्चित हैं, उनके लिए संकेत विनिमेय हैं। यह लचीलापन सी को समान कोड का उपयोग करके किसी भी लम्बाई सरणी में हेरफेर करने की अनुमति देता है। यह प्रोग्रामर को आवंटित सरणी के बाहर न लिखने का उत्तरदायित्व भी नहीं देता है, क्योंकि भाषा में कोई जाँच नहीं की जाती है।

पास्कल में, सरणियाँ पॉइंटर्स से अलग होता हैं। यह एक संकलक परिप्रेक्ष्य से सरणियों की सीमा जाँच को संभव बनाता है। व्यावहारिक रूप से सभी पास्कल संकलक एक संकलन विकल्प के रूप में परिसर जाँच का समर्थन करते हैं। दोनों में सरणी होने की क्षमता जो जो क्रम पर लंबाई बदलती है, और भाषा नियंत्रण के अनुसार जांचने में सक्षम होती है, को अधिकांशतः "डायनामिक सरणी" कहा जाता है। पास्कल में प्रत्येक सरणी में तत्वों की संख्या संकलन-समय पर निर्धारित की जाती है और प्रोग्राम के निष्पादन के समय इसे बदला नहीं जा सकता है। इसलिए, ऐसे सरणी को परिभाषित करना संभव नहीं है जिसकी लंबाई किसी भी तरह से प्रोग्राम डेटा पर निर्भर करती है।

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

static char *wordlist[] = {
  "print",   "out",   "the",  "text",   "message" };
static int listSize = (sizeof(wordlist)/sizeof(wordlist[0]));
int i;

for (i=0; i<listSize; i++)
  puts(wordlist[i]);
for (i=listSize-1; i>=0; i--)
  puts(wordlist[i]);

मूल पास्कल में न तो सरणी आरंभीकरण (तारों के स्थितियों े के बाहर) है और न ही संकलन समय पर मनमाना सरणी आकार निर्धारित करने का साधन है।

पास्कल में उपरोक्त उदाहरण को लागू करने का एक विधि है, किन्तु स्वत: आकार समायोजन के बिना, यह है:

const
  minlist = 1;
  maxlist = 5;
  maxword = 7;

type
  listrange = minlist .. maxlist;
  wordrange = 1..maxword;
  word = record
    contents: packed array [wordrange] of char;
    length: wordrange
  end;
  wordlist = array[listrange] of word;
var
  i: integer;
  words: wordlist;

procedure CreateList(var w: wordlist);
begin
  w[1].contents := 'print  ';
  w[1].length := 5;
  w[2].contents := 'out    ';
  w[2].length := 3;
  w[3].contents := 'the    ';
  w[3].length := 3;
  w[4].contents := 'text   ';
  w[4].length := 4;
  w[5].contents := 'message';
  w[5].length := 7;
end;

begin
  CreateList(words);
  for i := minlist to maxlist do
    with words[i] do
      WriteLn(contents: length);
  for i := maxlist downto minlist do
    with words[i] do
      WriteLn(contents: length)
end.

स्ट्रिंग्स

दोनों भाषाओं में, एक स्ट्रिंग वर्णों का एक आदिम सरणी है।

पास्कल में लंबाई n का एक स्ट्रिंग अक्षर प्रकार के साथ संगत है packed array [1..n] of char. सी में एक स्ट्रिंग में सामान्यतः प्रकार होता है char[n].

पास्कल के पास चर-लंबाई सरणियों के लिए कोई समर्थन नहीं है, और इसलिए स्ट्रिंग संचालन करने के लिए रूटीन का कोई भी सेट एक विशेष स्ट्रिंग आकार पर निर्भर है। अब मानकीकृत पास्कल अनुरूप सरणी पैरामीटर एक्सटेंशन इसे अधिक हल करता है, और पास्कल के कई या यहां तक ​​कि अधिकांश कार्यान्वयन भाषा के मूल स्ट्रिंग के लिए समर्थन करते हैं।

सी स्ट्रिंग लिटरल अशक्त-समाप्त स्ट्रिंग हैं | नल-टर्मिनेटेड; यह कहना है, एक अनुगामी अशक्त वर्ण अंत-की-स्ट्रिंग प्रहरी मान के रूप में:

const char *p;
p = "the rain in Spain";     /* null-terminated */

सरणियों में संग्रहीत स्ट्रिंग चर के लिए अशक्त-समाप्ति को मैन्युअल रूप से बनाए रखा जाना चाहिए (यह अधिकांशतः लाइब्रेरी रूटीन द्वारा आंशिक रूप से नियंत्रित किया जाता है)।

सी में अंतर्निहित स्ट्रिंग या सरणी असाइनमेंट की कमी है, इसलिए स्ट्रिंग को पी में स्थानांतरित नहीं किया जा रहा है, जबकि पी को स्मृति में निरंतर स्ट्रिंग को इंगित करने के लिए बनाया जा रहा है।

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

मुफ़्त बीएसडी डेवलपर पॉल-हेनिंग काम्प, एसीएम पंक्ति, में लिखते हुए, बाद में लंबाई-प्रीफ़िक्स्ड स्ट्रिंग्स पर नल-टर्मिनेटेड स्ट्रिंग्स की जीत को अब तक की सबसे महंगी एक-बाइट गलती के रूप में संदर्भित करेंगे।

रिकॉर्ड प्रकार

सी और पास्कल दोनों वस्तु संरचना प्रकार घोषित कर सकते हैं। सी में, उन्हें संरचनाएं कहा जाता है।

struct a {
   int b;
   char c;
};

type a = record
   b: integer;
   c: char;
end;

पास्कल में, हम name_of_record.name_of_field लिखने के अतिरिक्त उस रिकॉर्ड की फ़ील्ड्स जैसे स्थानीय चरों का सीधे उपयोग करने के लिए name_of_record do वाले वाक्य का उपयोग कर सकते हैं। यहाँ एक उदाहरण है:

type
 r = record
   s: string;
   c: char;
 end;
var
r1 : r;
begin
with r1 do begin
  s := 'foo';
  c := 'b';
end;

C में with के समान कोई विशेषता नहीं है।

सी में, फ़ील्ड की त्रुटिहीन बिट लंबाई निर्दिष्ट की जा सकती है:

struct a {
   unsigned int b:3;
   unsigned int c:1;
};

कितना भंडारण उपयोग किया जाता है यह लक्ष्य प्रणाली के लक्षणों (जैसे, शब्द-संरेखण) पर निर्भर करता है।

यह सुविधा पास्कल में सबरेंज कंस्ट्रक्शन (3 बिट्स 0 से 7 तक की सीमा देता है) का उपयोग करके कीवर्ड पैक के साथ उपलब्ध है:

type a = packed record
   b: 0..7;
   c: 0..1;
end;

सी और पास्कल दोनों रिकॉर्ड का समर्थन करते हैं जिसमें एक दूसरे को ओवरलैप करने वाले विभिन्न फ़ील्ड सम्मलित हो सकते हैं:

union a {
   int a;
   float b;
};

type a = record
   case boolean of
      false: (a: integer);
      true:  (b: real)
end;

यूनियन /रिकॉर्ड में सबसे बड़ा प्रकार सम्मलित करने के लिए आवश्यक दोनों भाषा प्रोसेसर इन अभिलेखों के लिए केवल उतना ही स्थान आवंटित करने के लिए स्वतंत्र हैं।

सी और पास्कल के बीच सबसे बड़ा अंतर यह है कि पास्कल टैग किए गए यूनियन का समर्थन करता है। भाषा प्रोसेसर के लिए टैगफील्ड का स्पष्ट उपयोग यह निर्धारित करने के लिए कि वेरिएंट रिकॉर्ड के वैध घटक का उपयोग किया जा रहा है या नहीं:

type a = record
   case q: boolean of
      false: (a: integer);
      true:  (b: real)
end;

इस स्थिति में, रिकॉर्ड के उचित भागों तक पहुँचने के लिए टैग फ़ील्ड q को सही स्थिति में सेट किया जाना चाहिए।

पॉइंटर्स

सी में, ऑब्जेक्ट्स या फलन सहित अधिकांश प्रोग्राम संस्थाओं को इंगित करने के लिए पॉइंटर्स बनाए जा सकते हैं:

int a;
int *b;
int (*compare)(int c, int d);
int  MyCompare(int c, int d);
 
b = &a;
compare = &MyCompare;

सी में, चूंकि सरणी और पॉइंटर्स के पास समानता है, निम्न समान हैं:

a = b[5];
a = *(b+5);
a = *(5+b);
a = 5[b];

इस प्रकार, पॉइंटर्स का उपयोग अधिकांशतः C में सरणियों तक पहुँचने के लिए एक अन्य विधि के रूप में किया जाता है।

गतिशील डेटा बनाने के लिए, पुस्तकालय कार्य करता है malloc() और free() डेटा के गतिशील ब्लॉक प्राप्त करने और जारी करने के लिए उपयोग किया जाता है। इस प्रकार, डायनेमिक मेमोरी आवंटन भाषा प्रोसेसर में नहीं बनाया गया है। यह विशेष रूप से मूल्यवान है जब C का उपयोग ऑपरेटिंग प्रणाली कर्नेल या एम्बेडेड लक्ष्यों में किया जा रहा है क्योंकि ये चीजें बहुत ही प्लेटफ़ॉर्म (न केवल आर्किटेक्चर) विशिष्ट हैं और प्रत्येक प्लेटफ़ॉर्म (या ऑपरेटिंग प्रणाली ) के लिए C संकलक को बदलने की आवश्यकता होगी, जिस पर इसका उपयोग किया जाएगा।

पास्कल में C के समान पॉइंटर्स नहीं होते हैं, किन्तु इसमें एक अप्रत्यक्ष संचालक होता है जो C पॉइंटर्स के सबसे सामान्य उपयोग को कवर करता है। प्रत्येक सूचक एक गतिशील डेटा आइटम के लिए बाध्य है, और केवल असाइनमेंट द्वारा स्थानांतरित किया जा सकता है:

type a = ^integer;

var b, c: a;

new(b);
c := b;

पास्कल में पॉइंटर्स टाइप सेफ होते हैं; अर्थात एक डेटा प्रकार के लिए एक सूचक केवल उसी डेटा प्रकार के सूचक को असाइन किया जा सकता है। साथ ही पॉइंटर्स को नॉन-पॉइंटर परिवर्त्य्स को कभी भी असाइन नहीं किया जा सकता है। पास्कल में पॉइंटर अंकगणित (सी में प्रोग्रामिंग त्रुटियों का एक सामान्य स्रोत, विशेष रूप से endianness मुद्दों और प्लेटफ़ॉर्म-स्वतंत्र प्रकार के आकारों के साथ संयुक्त होने पर) की अनुमति नहीं है।

ये सभी प्रतिबंध सी की तुलना में पास्कल में सूचक संबंधी त्रुटियों की संभावना को कम करते हैं, किन्तु पास्कल में अमान्य सूचक संदर्भों को पूरी तरह से नहीं रोकते हैं। उदाहरण के लिए, एक रनटाइम त्रुटि तब होगी जब किसी सूचक को आरंभिक होने से पहले या उसके निपटारे के बाद संदर्भित किया गया हो।

भाव

वरीयता स्तर

जब अभिव्यक्ति मूल्यांकन की बात आती है तो भाषाएँ महत्वपूर्ण रूप से भिन्न होती हैं, किन्तु कुल मिलाकर वे तुलनीय हैं।

पास्कल

1. तार्किक निषेध: not
2. गुणक: * / div mod and
3. योज्य: + - or
4. संबंधपरक: = <> < > <= >= in

सी

1. यूनरी पोस्टफिक्स: [] () . -> ++ --
2. यूनरी उपसर्ग: & * + - ! ~ ++ -- (type) sizeof
3. गुणक: * / %
4. योज्य: + -
5. बदलाव: << >>
6. संबंधपरक: < > <= >=
7. समानता: == !=
8. बिटवाइज़ और: &
9. बिटवाइज़ एक्सोर: ^
10. बिटवाइज़ या: |
11. तार्किक और: &&
12. तार्किक या: ||
13. सशर्त: ? :
14. कार्यभार: = += -= *= /= %= <<= >>= &= ^= |=
15. कॉमा संचालक : ,

टाइपिंग

अधिकांश संचालक पास्कल में कई उद्देश्यों की पूर्ति करते हैं, उदाहरण के लिए, नकारात्मक चिह्न का उपयोग निषेध, घटाव या सेट अंतर के लिए किया जा सकता है (दोनों प्रकार और वाक्यात्मक संदर्भ के आधार पर), >= संचालक का उपयोग संख्याओं, स्ट्रिंग्स या सेटों आदि की तुलना करने के लिए किया जा सकता है। सी अधिक हद तक समर्पित संचालक प्रतीकों का उपयोग करता है।

असाइनमेंट और समानता परीक्षण

दो भाषाएँ असाइनमेंट के लिए अलग-अलग संचालकों का उपयोग करती हैं। पास्कल, ऐल्गॉल की तरह, गणितीय समानता संचालक का उपयोग करता है = समानता परीक्षण और प्रतीक के लिए := असाइनमेंट के लिए, जबकि C, जैसे B (प्रोग्रामिंग भाषा ), असाइनमेंट के लिए गणितीय समानता संचालक का उपयोग करता है। सी (और बी) में नया == प्रतीक इसलिए समानता परीक्षण के लिए प्रस्तुत किया गया था।

यह C में एक सामान्य गलती है, या तो अनुभवहीनता या एक साधारण टाइपिंग त्रुटि के कारण, गलती से असाइनमेंट एक्सप्रेशन को सशर्त कथनों में डाल दिया जाता है जैसे if (a = 10) { ... }. असाइनमेंट एक्सप्रेशन के कारण ब्रेसिज़ में कोड सदैव निष्पादित होगा a = 10 का मान 10 है जो गैर-शून्य है और इसलिए C में सत्य माना जाता है; यह भाग में है क्योंकि C (और ऐल्गॉल) फॉर्म में कई असाइनमेंट की अनुमति देता है a = b = c = 10; जो पास्कल द्वारा समर्थित नहीं है। यह भी ध्यान दें a अब मूल्य है 10, जो निम्नलिखित कोड को प्रभावित कर सकता है। हाल के सी संकलक इन स्थितियों का पता लगाने की कोशिश करते हैं और उपयोगकर्ता को कम अस्पष्ट सिंटैक्स की तरह पूछते हुए चेतावनी देते हैं if ((a=10) != 0 ) { ... }.

पास्कल में इस तरह की गलती नहीं हो सकती है, क्योंकि असाइनमेंट एक्सप्रेशन नहीं हैं और उनका कोई मूल्य नहीं है: गलत संचालक का उपयोग करने से एक स्पष्ट संकलन त्रुटि होगी, और यह भी कम संभावना है कि कोई भी गलती करेगा := समानता परीक्षण के लिए प्रतीक।

यह उल्लेखनीय है कि ऐल्गॉल की सशर्त अभिव्यक्ति के रूप में a := if a > b then a else b; सी में समतुल्य है किन्तु पास्कल में नहीं है।

कार्यान्वयन मुद्दे

जब निकलॉस विर्थ ने पास्कल को डिज़ाइन किया, तो वांछित प्राथमिकता के स्तरों की संख्या को सीमित करने की थी (आखिरकार कम पार्स रूटीन)। इसलिए OR और विशिष्ट OR संचालक को एक ऐडॉप की तरह ही माना जाता है और एक गणित अभिव्यक्ति के स्तर पर संसाधित किया जाता है।इसी तरह, AND को मुलोप की तरह माना जाता है और टर्म के साथ संसाधित किया जाता है। प्राथमिकता स्तर होती हैं

           Level   Syntax Element     Operator

         0       factor             literal, variable
           1       signed factor      unary minus, NOT
          2       term               *, /, AND
         3       expression         +, -, OR

ध्यान दें कि सिंटैक्स नियमों का केवल एक ही सेट है, जो दोनों प्रकार के ऑपरेटरों पर लागू होता है। इस व्याकरण के अनुसार अभिव्यक्ति जैसे

    x + (y AND NOT z) / 3

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

C के लेखकों ने बिल्कुल विपरीत दृष्टिकोण अपनाया: वे संचालकों को अलग-अलग मानते हैं, और वास्तव में, C में 15 से कम स्तर नहीं होते हैं। ऐसा इसलिए है क्योंकि C में संचालक '=', '+=' और उसके परिजन, '<<', '>>', '++', '--', आदि भी हैं। चूँकि C में अंकगणित और बूलियन संचालक हैं अलग से व्यवहार किया जाता है, चर नहीं हैं: किसी भी पूर्णांक मान पर बूलियन परीक्षण किया जा सकता है।

तार्किक संयोजक

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

C में, बूलियन मूल्यांकन क्रम पर निर्भरता पूरी तरह से सैद्धांतिक है, और अधिकांशतः && और || का उपयोग करके व्यवस्थित रूप से नियोजित की जाती है जैसे ++, +=,अल्पविराम संचालक , जैसे संचालकों के साथ आदि && और || इस प्रकार संचालक तार्किक संचालकों और सशर्त कथनों के संयोजन के रूप में कार्य करते हैं।

मूल्यांकन समस्या के कारण शॉर्ट परिपथ अभिव्यक्ति मूल्यांकन को सामान्यतः C के लिए एक लाभ माना गया है:

var i: integer;
    a: packed array [1..10] of char;
  
  ...
  i := 1;
  while (i <= 10) and (a[i] <> 'x') do i := i+1;
  ...

पास्कल में यह प्रतीत होता है सरल खोज पास्कल में समस्याग्रस्त है क्योंकि एरे एक्सेस ए[आई] 11 के बराबर के लिए अमान्य होगा। इस समस्या से बचने के एक से अधिक विधिया हैं। निम्नलिखित उदाहरण एक बूलियन वैरिएबल का परिचय देता है जो इंगित करता है कि लक्ष्य वर्ण पाया गया है या नहीं:

const
  strlen = 10;
var i: integer;
    a: packed array [1..strlen] of char;
    found: boolean;
  
  ...
  i := 1;
  found := false;
  while not found and (i <= strlen) do
    if (a[i] = 'x') then found := true else i := i+1;
  ...

नियंत्रण संरचनाएं

नियंत्रण संरचनाओं के निर्माण के लिए कथन मोटे तौर पर समान और अपेक्षाकृत होते हैं (कम से कम पहले तीन)।

पास्कल में है:

• if cond then stmt else stmt
• while cond do stmt
• repeat stmt until cond
• for id := expr to expr do stmt and for id := expr downto expr do stmt
• case expr of expr : stmt; ... expr : stmt; else: stmt; end

सी है:

• if (cond) stmt else stmt
• while (cond) stmt
• do stmt while (cond);
• for (expr; cond; expr) stmt
• switch (expr) { case expr : stmt; ... case expr : stmt; default: stmt }

पास्कल, अपने मूल रूप में, डिफ़ॉल्ट के समकक्ष नहीं था, किन्तु एक समान अन्य खंड एक सामान्य विस्तार है। पास्कल प्रोग्रामर को अन्यथा अभिव्यक्ति के साथ केस-स्टेटमेंट की रक्षा करनी पड़ती थी: if expr not in [A..B] then default-case.

सी में तथाकथित अर्ली-आउट स्टेटमेंट ब्रेक और जारी हैं, और कुछ पास्कल के पास भी हैं।

C और पास्कल दोनों का गोटो विवरण होता है। चूँकि , पास्कल में नेस्टेड प्रक्रियाएँ/कार्य होती हैं, इसलिए आंतरिक प्रक्रिया या फ़ंक्शन से युक्त फ़ंक्शन में वृधि की जा सकती है; यह सामान्यतः त्रुटि पुनर्प्राप्ति को लागू करने के लिए उपयोग किया जाता था। C के पास ANSI Csetjmp और longjmp के माध्यम से यह क्षमता होती है। यह समतुल्य है, किन्तु कम सुरक्षित है, क्योंकि यह प्रोग्रामर की पहुंच योग्य संरचना में जंप एड्रेस और स्टैक फ्रेम जैसी प्रोग्राम विशिष्ट जानकारी संग्रहीत करता है।

कार्य और प्रक्रियाएं

पास्कल नित्यक्रम जो मान प्रतिलाभ देते उन्हें फलन कहा जाता है; जो नित्यक्रम कोई मान प्रतिलाभ नहीं देते हैं उन्हें प्रक्रियाएँ कहा जाता है। C में सभी रूटीन को फलन कहा जाता है; C फलन जो कोई मान नहीं लौटाते हैं उन्हें रिटर्न प्रकार के शून्य के साथ घोषित किया जाता है।

पास्कल प्रक्रियाओं को सी शून्य कार्यों के बराबर माना जाता है, और पास्कल कार्यों को सी कार्यों के बराबर माना जाता है जो मान लौटाते हैं।

C में निम्नलिखित दो घोषणाएँ:

int f(int x, int y);
void k(int q);

पास्कल में निम्नलिखित घोषणाओं के बराबर होता हैं:

function f(x, y: integer): integer;
procedure k(q: integer);

पास्कल के दो अलग-अलग प्रकार के पैरामीटर हैं: पास-बाय-वैल्यू और पास-बाय-रेफरेंस (VAR)।

function f(var k: integer): integer;
x := f(t);

सी में सभी पैरामीटर वैल्यू द्वारा पास किए जाते हैं किन्तु पास-बाय-रेफरेंस को पॉइंटर्स का उपयोग करके सिम्युलेट किया जा सकता है। निम्नलिखित खंड उपरोक्त पास्कल खंड के समान है:

int f(int *k); //function accepts a pointer as parameter
x = f(&t);

C फलन को पैरामीटर की एक चर संख्या को स्वीकार करने की अनुमति देता है, जिसे वैरिएडिक फलन के रूप में जाना जाता है।

int f(int a, ...);
f(1, 2, 3, 4, 5);

कार्यक्रम f() कार्यों के एक विशेष सेट का उपयोग करता है जो बदले में प्रत्येक पैरामीटर को एक्सेस करने की अनुमति देता है।

इसके अतिरिक्त पास्कल में I/O कथन भाषा में बनाए गए पैरामीटर की परिवर्तनीय मात्रा को संभालने के लिए हैं Writeln. पास्कल प्रक्रियाओं और कार्यों को नेस्टेड कार्य करने की अनुमति देता है। प्रक्रियाओं के एक समारोह सूचक लिए स्थानीय चर की अनुमति देना सुविधाजनक है, किन्तु वैश्विक नहीं है। C में इस सुविधा का अभाव है और चर या कार्यों का स्थानीयकरण केवल एक संकलन मॉड्यूल के लिए किया जा सकता है जिसमें चर या कार्यों को स्थिर घोषित किया गया होगा।

सी कार्यों को अप्रत्यक्ष रूप नेस्टेड समारोह पॉइंटर के माध्यम से लागू करने की अनुमति देता है। निम्नलिखित उदाहरण में, कथन (*cmpar)(s1, s2) के बराबर होता है strcmp(s1, s2):

#include <string.h>

int (*cmpar)(const char *a, const char *b);
const char *s1 = "hello";
const char *s2 = "world";

cmpar = &strcmp;
b = (*cmpar)(s1, s2);

पास्कल भी कार्यों और प्रक्रियाओं को कार्यों या प्रक्रियाओं के पैरामीटर के रूप में पारित करने की अनुमति देता है:

procedure ShowHex(i: integer);
...
end;

procedure ShowInt(i: integer);
...
end;

procedure Demo(procedure Show(i: integer));
var j: integer;
begin
  Show(j)
end;

...
  Demo(ShowHex);
  Demo(ShowInt);
...

पूर्वसंसाधित्र

प्रारंभिक C में न तो निरंतर घोषणाएँ थीं और न ही प्रकार की घोषणाएँ, और सी भाषा को मूल रूप से एक प्रीप्रोसेसर की आवश्यकता के रूप में परिभाषित किया गया था; मेमोरी उपयोग को कम रखने के लिए एक अलग प्रोग्राम, और पास, जो स्थिर, सम्मलित होती है और मैक्रो (कंप्यूटर विज्ञान) परिभाषाएं संभालता है। बाद में, एएनएसआई सी के साथ, इसने निरंतर और प्रकार की परिभाषाएं प्राप्त कीं और प्रीप्रोसेसर भी भाषा का हिस्सा बन गया, जो आज हम देखते हैं कि सिंटैक्स के लिए अग्रणी है।

पास्कल स्थिरांक और प्रकार परिभाषित किए गए हैं, किन्तु पास्कल के साथ एक प्रीप्रोसेसर का उपयोग करने वाले प्रोग्रामर थे (कभी-कभी वही सी के साथ प्रयोग किया जाता है), निश्चित रूप से C के साथ उतना सामान्य नहीं है। चूँकि अधिकांशतः पास्कल की कमी के रूप में इंगित किया जाता है, तकनीकी रूप से सी करता है न तो प्रोग्राम मॉड्युलैरिटी है और न ही मैक्रोज़ इन में निर्मित हैं। इसमें एक साधारण निम्न स्तर की अलग संकलन सुविधा है, चूँकि (परंपरागत रूप से असेंबली भाषा के लिए उपयोग किए जाने वाले समान सामान्य लिंकर का उपयोग करते हुए), पास्कल नहीं करता है।

टाइप एस्केप

C में, प्रोग्रामर किसी वस्तु पर चार पॉइंटर इंगित करके उसके बाइट-स्तरीय प्रतिनिधित्व का निरीक्षण कर सकता है:

int a;
char *p = (char *)(&a);
char c = *p;  // first byte of a

पास्कल में एक अविभेदित संस्करण रिकॉर्ड का उपयोग करना संभव हो सकता है:

var a: integer;
    b: real;
    a2c: record
           case boolean of
             false: (a: integer);
             true:  (b: real);
           end;
         end;
begin
  a2c.b := b;
  a := a2c.a;
end;

चूँकि अधिकांश पास्कल संकलनकर्ता और दुभाषियों पर विभुंचन संभव होता है, यहां तक ​​​​कि a2c.a और a2c.b के ऊपर के कोड में भी समान पता स्थान साझा करने के लिए किसी भी पास्कल मानकीकरण की आवश्यकता नहीं होती है। पास्कल के डिज़ाइनर निकलॉस विर्थ ने इस दृष्टिकोण का उपयोग करके टाइप एस्केप के प्रयास की समस्याग्रस्त प्रकृति के बारे में लिखा है:

पास्कल के अधिकांश कार्यान्वयनकर्ताओं ने निर्णय लिया कि यह जाँच बहुत महंगी होगी, कोड का बढ़ाना और प्रोग्राम दक्षता को कम करना। परिणामस्वरूप, ट्रिक्स के शौकीन सभी प्रोग्रामर द्वारा टाइप प्रणाली का उल्लंघन करने के लिए भिन्न रिकॉर्ड अनुकूल सुविधा बन गई, जो सामान्यतः नुकसान और आपदाओं में बदल जाती है।

कई भाषाएँ विशेष रूप से इस प्रकार के एस्केप को बाहर कर देती हैं, उदाहरण के लिए जावा, C# और विर्थ की अपनी ओबेरॉन (प्रोग्रामिंग भाषा) होती है।

फाइलें

C में फ़ाइलें अंतर्निहित रूप से सम्मलित नहीं होती हैं (उन्हें प्रणाली हेडर में परिभाषित किया जाता है) और सभी I/O लाइब्रेरी कॉल के माध्यम से होते हैं। पास्कल में फ़ाइल प्रबंधन भाषा में अंतर्निहित होती है।

प्रत्येक भाषा में I/O निष्पादित करने के लिए उपयोग किए जाने वाले विशिष्ट कथन हैं:

printf("The sum is: %d\n", x);

writeln('The sum is: ', x);

मुख्य अंतर यह है कि C एक "प्रारूप श्रृंखला" का उपयोग करता है जिसे जिसे प्रिंटफ फलन में तर्क ढूंढने और उन्हें परिवर्तित करने के लिए व्याख्या किया जाता है, जबकि पास्कल भाषा प्रोसेसर के नियंत्रण में ऐसा करता है। पास्कल विधि यकीनन तेज होती है, क्योंकि इसकी कोई व्याख्या नहीं होती है, किन्तु C विधि अत्यधिक विस्तार योग्य होती है।

बाद में पास्कल कार्यान्वयन और विस्तार

कुछ लोकप्रिय पास्कल कार्यान्वयनों ने पास्कल में वस्तुतः सभी C निर्माणों को सम्मलित किया है। उदाहरणों में टाइप कास्ट, किसी भी चर, स्थानीय या वैश्विक का पता प्राप्त करने में सक्षम होना और विशेष प्रचार गुणों के साथ विभिन्न प्रकार के पूर्णांक सम्मलित होते है।

चूँकि, प्रकार और प्रकार के रूपांतरणों के प्रति C के नम्र प्रवृति समावेश के परिणामस्वरूप पास्कल अपनी कुछ या सभी प्रकार की सुरक्षा खो सकता है। उदाहरण के लिए, जावा (प्रोग्रामिंग भाषा) और C# को सी के कुछ कथित प्रकार के सुरक्षा मुद्दों को संबोधित करने के लिए बनाया गया था, और इसमें "प्रबंधित" पॉइंटर्स हैं, जिनका उपयोग अमान्य संदर्भ बनाने के लिए नहीं किया जा सकता है। अपने मूल रूप में (जैसा कि निकलॉस विर्थ द्वारा वर्णित है), पास्कल एक प्रबंधित सूचक भाषा के रूप में अर्हता प्राप्त करता है, या तो जावा या C# से लगभग 30 साल पहले हुआ था। चूँकि, C के साथ समामेलित पास्कल परिभाषा के अनुसार उस सुरक्षा को खो देगा। सामान्यतः,बुनियादी कार्यों के लिए पॉइंटर्स पर कम निर्भरता इसे व्यवहार में C की तुलना में अधिक सुरक्षित बनाती है।

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

यह भी देखें

• सी (प्रोग्रामिंग भाषा), सी ++
• पास्कल (प्रोग्रामिंग भाषा ), वस्तु पास्कल , फ्री पास्कल, डेल्फी (प्रोग्रामिंग भाषा) , ऑक्सीजन (प्रोग्रामिंग भाषा )
• घटक पास्कल

अग्रिम पठन

• Kathleen Jensen and Niklaus Wirth: PASCAL - User Manual and Report. Springer-Verlag, 1974, 1985, 1991, ISBN 3-540-97649-3 https://web.archive.org/web/20050314152247/http://www.cs.inf.ethz.ch/~wirth/books/Pascal/]
• Brian Kernighan, Dennis Ritchie: The C Programming Language. Also called K&R – the original book on C.
  • 1st, Prentice Hall 1978; ISBN 0-13-110163-3. Pre-ANSI C.
  • 2nd, Prentice Hall 1988; ISBN 0-13-110362-8. ANSI C.
• Niklaus Wirth: Comment on a note on dynamic arrays in PASCAL 37-38, ACM SIGPLAN Notices, Volume 11, Issue 1, January 1976.
• Niklaus Wirth: Recollections about the Development of Pascal. 333-342, ACM SIGPLAN Notices, Volume 28, Issue 3, March 1993.
• ISO/IEC 9899. The official C:1999 standard, along with defect reports and a rationale.
• Detailed analysis of converting C to Pascal
• Alan R. Feuer, Narain H. Gehani: Comparison of the Programming Languages C and Pascal 73-92, ACM Computing Surveys, Volume 14, Issue 1, March 1982.
• Comparing and Assessing Programming Languages: Ada, C and Pascal, Ed. by Alan R. Feuer and Narain Gehani, Prentice Hall, 1984. ISBN 0-13-154840-9
• Scott Meyers: Effective C++, 2nd Ed., Addison-Wesley, 1998, ISBN 0-201-92488-9
• Vincent Hayward: Compared anatomy of the programming languages Pascal and C 50-60, ACM SIGPLAN Notices, Volume 21, Issue 5, May 1986.
• Pascal for C users in the FreePascal Compiler Wiki