Die Eingabe von eckigen Klammern []ist einfacher, seit dem IBM 2741- Terminal, das unter Multics- Betriebssystemen "weit verbreitet" war und für das Dennis Ritchie, einer der Entwickler der Programmiersprache C, Mitglied des Entwicklerteams war .
Beachten Sie das Fehlen von geschweiften Klammern im IBM 2741-Layout!
In C werden eckige Klammern "genommen", da diese für Arrays und Zeiger verwendet werden . Wenn Sprachentwickler erwarten würden, dass Arrays und Zeiger wichtiger / häufiger verwendet werden als Codeblöcke (was wie eine vernünftige Annahme neben ihnen klingt , mehr im historischen Kontext des Codierungsstils unten), würde dies bedeuten, dass geschweifte Klammern "weniger wichtig" werden " Syntax.
Die Bedeutung von Arrays wird in dem Artikel Die Entwicklung der C-Sprache von Ritchie deutlich. Es gibt sogar eine explizit angegebene Annahme der "Prävalenz von Zeigern in C-Programmen" .
... Neue Sprache behielt eine kohärente und praktikable (wenn auch ungewöhnliche) Erklärung der Semantik von Arrays ... Zwei Ideen sind für C unter den Sprachen seiner Klasse am charakteristischsten : die Beziehung zwischen Arrays und Zeigern ... Das andere charakteristische Merkmal von C, seine Behandlung von Arrays ... hat echte Tugenden . Obwohl die Beziehung zwischen Zeigern und Arrays ungewöhnlich ist, kann sie gelernt werden. Darüber hinaus zeigt die Sprache beträchtliche Macht wichtige Konzepte zu beschreiben, beispielsweise Vektoren , deren Länge variiert während der Laufzeit, mit nur ein paar grundlegenden Regeln und Konventionen ...
Für ein besseres Verständnis des historischen Kontexts und des Codierungsstils der Zeit, als die C-Sprache erstellt wurde, muss berücksichtigt werden, dass "der Ursprung von C eng mit der Entwicklung von Unix verknüpft ist " und insbesondere, dass das Betriebssystem auf einen PDP portiert wird. 11 "führte zur Entwicklung einer frühen Version von C" ( zitiert Quelle ). Laut Wikipedia , "im Jahr 1972 wurde Unix in der Programmiersprache C neu geschrieben" .
Der Quellcode verschiedener alter Versionen von Unix ist online verfügbar, z. B. auf der Unix Tree- Site. Von den verschiedenen dort vorgestellten Versionen scheint die zweite Ausgabe von Unix vom 1972-06 die relevanteste zu sein :
Die zweite Ausgabe von Unix wurde von Ken Thompson, Dennis Ritchie und anderen für den PDP-11 bei Bell Labs entwickelt. Es erweiterte die First Edition mit mehr Systemaufrufen und mehr Befehlen. In dieser Ausgabe begann auch die C-Sprache, mit der einige Befehle geschrieben wurden ...
Sie können C-Quellcode auf der Second Edition Unix (V2) -Seite durchsuchen und studieren , um eine Vorstellung vom typischen Codierungsstil der Zeit zu erhalten.
Ein prominentes Beispiel, das die Idee unterstützt, dass es für Programmierer damals ziemlich wichtig war, eckige Klammern mühelos einzugeben, findet sich im Quellcode von 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;
Es ist interessant festzustellen, dass die pragmatische Motivation, Zeichen auszuwählen, um sprachliche Syntaxelemente zu kennzeichnen, die auf ihrer Verwendung in gezielten praktischen Anwendungen basieren, dem Zipfschen Gesetz ähnelt, wie in dieser hervorragenden Antwort erläutert ...
Die beobachtete Beziehung zwischen Frequenz und Länge wird als Zipf-Gesetz bezeichnet
... mit dem einzigen Unterschied, dass die Länge in der obigen Anweisung durch / generalisiert als Schreibgeschwindigkeit ersetzt wird.