वर्ग ब्रेसिज़ []टाइप करना आसान है, कभी आईबीएम 2741 टर्मिनल के बाद से "मल्टीिक्स पर व्यापक रूप से उपयोग किया जाने वाला" ओएस, जिसमें बदले में डेनिस रिची, सी भाषा रचनाकारों में से एक देव टीम सदस्य थे ।
आईबीएम 2741 लेआउट में घुंघराले ब्रेसिज़ की अनुपस्थिति पर ध्यान दें !
सी में, वर्ग ब्रेसिज़ को "लिया" जाता है क्योंकि इनका उपयोग सरणियों और बिंदुओं के लिए किया जाता है । यदि भाषा डिजाइनरों ने सरणियों और बिंदुओं की अपेक्षा की, जो कोड ब्लॉकों की तुलना में अधिक महत्वपूर्ण / बार-बार उपयोग किए जाते हैं (जो उनकी तरफ एक उचित धारणा की तरह लगता है, नीचे कोडिंग शैली के ऐतिहासिक संदर्भ में अधिक है), तो इसका मतलब होगा कि घुंघराले ब्रेसिज़ "कम महत्वपूर्ण" होंगे " वाक्य - विन्यास।
लेख का विकास द रिची द्वारा सी लैंग्वेज में एरे का महत्व बहुत स्पष्ट है । यहां तक कि "सी कार्यक्रमों में संकेत की व्यापकता" के बारे में भी स्पष्ट रूप से कहा गया है ।
... नई भाषा ने सरणियों के शब्दार्थ की एक सुसंगत और व्यावहारिक (यदि असामान्य है) व्याख्या को बनाए रखा है ... दो विचार इसके वर्ग की भाषाओं के बीच सी की सबसे अधिक विशेषता हैं : सरणियों और बिंदुओं के बीच का संबंध ... अन्य विशिष्ट विशेषता सी, इसकी सरणियों का उपचार ... वास्तविक गुण हैं । हालांकि संकेत और सरणियों के बीच संबंध असामान्य है, यह सीखा जा सकता है। इसके अलावा, भाषा महत्वपूर्ण अवधारणाओं का वर्णन करने के लिए काफी शक्ति दिखाती है , उदाहरण के लिए, वैक्टर जिनकी लंबाई समय के साथ बदलती है, केवल कुछ बुनियादी नियमों और सम्मेलनों के साथ ...
ऐतिहासिक संदर्भ और उस समय की कोडिंग शैली को समझने के लिए जब सी भाषा बनाई गई थी, तो किसी को इस बात का ध्यान रखना होगा कि "सी की उत्पत्ति यूनिक्स के विकास के साथ निकटता से जुड़ी हुई है" और, विशेष रूप से, जो ओएस को पीडीपी में पोर्ट कर रहा है- 11 "सी के प्रारंभिक संस्करण के विकास का नेतृत्व किया" ( उद्धरण स्रोत )। विकिपीडिया के अनुसार , "1972 में, यू प्रोग्रामिंग को सी प्रोग्रामिंग भाषा में फिर से लिखा गया" ।
यूनिक्स के विभिन्न पुराने संस्करणों का स्रोत कोड यूनिक्स ट्री साइट पर ऑनलाइन उपलब्ध है । वहाँ प्रस्तुत विभिन्न संस्करणों में, सबसे अधिक प्रासंगिक लगता है दूसरा संस्करण यूनिक्स दिनांक 1972-06:
यूनिक्स के दूसरे संस्करण को केन थॉम्पसन, डेनिस रिची और अन्य द्वारा बेल लैब्स में पीडीपी -11 के लिए विकसित किया गया था। इसने पहले संस्करण को और अधिक सिस्टम कॉल और अधिक कमांड के साथ बढ़ाया। इस संस्करण में सी भाषा की शुरुआत भी देखी गई, जिसका इस्तेमाल कुछ आदेशों को लिखने के लिए किया गया था ...
आप उस समय की विशिष्ट कोडिंग शैली का अंदाजा लगाने के लिए दूसरे संस्करण यूनिक्स (V2) पृष्ठ से C स्रोत कोड को ब्राउज़ और अध्ययन कर सकते हैं ।
एक प्रमुख उदाहरण जो इस विचार का समर्थन करता है कि प्रोग्रामर के लिए यह महत्वपूर्ण था कि वर्ग ब्रैकेट को आसानी से टाइप करने में सक्षम होने के लिए V2 / c / ncc.c स्रोत कोड पाया जा सकता है :
/* C command */
main(argc, argv)
char argv[][]; {
extern callsys, printf, unlink, link, nodup;
extern getsuf, setsuf, copy;
extern tsp;
extern tmp0, tmp1, tmp2, tmp3;
char tmp0[], tmp1[], tmp2[], tmp3[];
char glotch[100][], clist[50][], llist[50][], ts[500];
char tsp[], av[50][], t[];
auto nc, nl, cflag, i, j, c;
tmp0 = tmp1 = tmp2 = tmp3 = "//";
tsp = ts;
i = nc = nl = cflag = 0;
while(++i < argc) {
if(*argv[i] == '-' & argv[i][1]=='c')
cflag++;
else {
t = copy(argv[i]);
if((c=getsuf(t))=='c') {
clist[nc++] = t;
llist[nl++] = setsuf(copy(t));
} else {
if (nodup(llist, t))
llist[nl++] = t;
}
}
}
if(nc==0)
goto nocom;
tmp0 = copy("/tmp/ctm0a");
while((c=open(tmp0, 0))>=0) {
close(c);
tmp0[9]++;
}
while((creat(tmp0, 012))<0)
tmp0[9]++;
intr(delfil);
(tmp1 = copy(tmp0))[8] = '1';
(tmp2 = copy(tmp0))[8] = '2';
(tmp3 = copy(tmp0))[8] = '3';
i = 0;
while(i<nc) {
if (nc>1)
printf("%s:\n", clist[i]);
av[0] = "c0";
av[1] = clist[i];
av[2] = tmp1;
av[3] = tmp2;
av[4] = 0;
if (callsys("/usr/lib/c0", av)) {
cflag++;
goto loop;
}
av[0] = "c1";
av[1] = tmp1;
av[2] = tmp2;
av[3] = tmp3;
av[4] = 0;
if(callsys("/usr/lib/c1", av)) {
cflag++;
goto loop;
}
av[0] = "as";
av[1] = "-";
av[2] = tmp3;
av[3] = 0;
callsys("/bin/as", av);
t = setsuf(clist[i]);
unlink(t);
if(link("a.out", t) | unlink("a.out")) {
printf("move failed: %s\n", t);
cflag++;
}
loop:;
i++;
}
nocom:
if (cflag==0 & nl!=0) {
i = 0;
av[0] = "ld";
av[1] = "/usr/lib/crt0.o";
j = 2;
while(i<nl)
av[j++] = llist[i++];
av[j++] = "-lc";
av[j++] = "-l";
av[j++] = 0;
callsys("/bin/ld", av);
}
delfil:
dexit();
}
dexit()
{
extern tmp0, tmp1, tmp2, tmp3;
unlink(tmp1);
unlink(tmp2);
unlink(tmp3);
unlink(tmp0);
exit();
}
getsuf(s)
char s[];
{
extern exit, printf;
auto c;
char t, os[];
c = 0;
os = s;
while(t = *s++)
if (t=='/')
c = 0;
else
c++;
s =- 3;
if (c<=8 & c>2 & *s++=='.' & *s=='c')
return('c');
return(0);
}
setsuf(s)
char s[];
{
char os[];
os = s;
while(*s++);
s[-2] = 'o';
return(os);
}
callsys(f, v)
char f[], v[][]; {
extern fork, execv, wait, printf;
auto t, status;
if ((t=fork())==0) {
execv(f, v);
printf("Can't find %s\n", f);
exit(1);
} else
if (t == -1) {
printf("Try again\n");
return(1);
}
while(t!=wait(&status));
if ((t=(status&0377)) != 0) {
if (t!=9) /* interrupt */
printf("Fatal error in %s\n", f);
dexit();
}
return((status>>8) & 0377);
}
copy(s)
char s[]; {
extern tsp;
char tsp[], otsp[];
otsp = tsp;
while(*tsp++ = *s++);
return(otsp);
}
nodup(l, s)
char l[][], s[]; {
char t[], os[], c;
os = s;
while(t = *l++) {
s = os;
while(c = *s++)
if (c != *t++) goto ll;
if (*t++ == '\0') return (0);
ll:;
}
return(1);
}
tsp;
tmp0;
tmp1;
tmp2;
tmp3;
यह ध्यान रखना दिलचस्प है कि लक्षित व्यावहारिक अनुप्रयोगों में उनके उपयोग के आधार पर भाषा के वाक्यविन्यास तत्वों को निरूपित करने के लिए पात्रों को चुनने की व्यावहारिक प्रेरणा जिप्पी के कानून से कैसे मिलती है जैसा कि इस भयानक उत्तर में बताया गया है ...
आवृत्ति और लंबाई के बीच मनाया गया संबंध जिपफ लॉ कहलाता है
... केवल इस अंतर के साथ कि उपरोक्त कथन में लंबाई टाइपिंग की गति के रूप में / सामान्यीकृत है।