Righe vuote in C

Ogni riga di codice che tieni sullo schermo viene salvata durante la programmazione.

Nei giorni in cui i K & R venivano scritti, gli schermi erano larghi 80 caratteri per 24 linee. Questo è tutto ciò che si vedeva in quel momento su una pagina. Gli editor visivi non erano ancora stati scritti - avevi strumenti più simili a quelli di ed (scritto nel 1971, C è del 1972).

Quando lavori in un simile ambiente, lo spazio verticale è importante. Le parentesi non necessarie per indicare un blocco rappresentano una linea "sprecata" sullo schermo. Mettere una parentesi graffa aperta sulla propria linea è un'altra linea sprecata. Elses with ears } else { rappresenta due righe salvate sullo schermo.

Quando si traccia il flusso del programma, può diventare difficile mantenere le cose nella propria testa, la dimensione del codice diventa limitata a circa una dimensione dello schermo (anche oggi è vero), forse due. Mentre la stampa di line in line editor non è ingombrante non è semplicemente scorrendo il mouse sul lato dello schermo (o premendo la pagina in giù in vi), sono comandi come .,.+10p a stampa le dieci righe successive, o .-10,.+10 su "fai scorrere verso l'alto 10 righe e mostra anche le dieci righe successive" - non è esattamente facile né per navigare il codice, né per spostarti da "pagina" a "pagina".

Se uno guarda Quante righe di codice sono troppe? su StackOverflow, verranno visualizzati diversi riferimenti a "dimensioni dello schermo".

Noi inconsciamente possiamo tenere nella nostra testa ciò che possiamo vedere, scambiando lo schermo. Se ti venisse fatta una domanda su qualcosa che si trova nella pagina di un libro che stai leggendo, è nella memoria a breve termine e puoi vederlo rapidamente e guardarlo per ottenere rapidamente il resto della memoria. Quando ti viene chiesto qualcosa di due pagine fa, potresti dover tornare indietro e aggiornare la memoria. Questo è ancora più critico quando si lavora con i programmi perché le cose piccole sono importanti ( x++ vs ++x ). Quindi ora devi tornare indietro e "scorrere" con ed, cosa che richiede un po 'di riflessione (che diventa uno dei punti di sette più o meno due e ha eliminato qualcos'altro).

Dall'altro "non salva spazio" cose nel blocco di codice e le loro ragioni ...

Se possibile, sono sorpreso dal codice nel non salvare altro spazio:

int mygetline(char s[], int lim)
{
  int c,i;

  for (i=0; i<lim-1 && (c=getchar()) != EOF && c!='\n'; ++i)
    s[i] = c;
  if (c == '\n')
    s[i++] = c;
  s[i] = '
/* power:  raise base to n-th power; n >= 0 */
/*         (old-style version) */
power(base, n)
int base, n;
{
    int i, p;

    p = 1;
    for (i = 1; i <= n; ++i)
        p = p * base;
    return p;
}
';
  return i;
}

Spostando l'incremento nell'assegnazione dell'array si possono rimuovere due linee (e sì, ci sono ancora più linee che possono essere rimosse per un codice più denso, il K & R sembra mantenere lo stile del codice della parentesi aperta per una funzione su una riga da sola e una riga vuota tra dichiarazioni e codice).

La parentesi aperta su una linea di per sé è probabilmente dallo stile originale della dichiarazione delle funzioni C. Dalla Sezione 1.7 in K & R (seconda edizione):

int mygetline(char s[], int lim)
{
  int c,i;

  for (i=0; i<lim-1 && (c=getchar()) != EOF && c!='\n'; ++i)
    s[i] = c;
  if (c == '\n')
    s[i++] = c;
  s[i] = '
/* power:  raise base to n-th power; n >= 0 */
/*         (old-style version) */
power(base, n)
int base, n;
{
    int i, p;

    p = 1;
    for (i = 1; i <= n; ++i)
        p = p * base;
    return p;
}
';
  return i;
}

Puoi vedere l'imbarazzo di spostare il riccio aperto per power su una riga precedente e, se possibile, aiuta a mantenere identificabile la dichiarazione della funzione.

Allo stesso modo, mantenendo un blocco di dichiarazione in alto e quindi una riga vuota. Questo era importante in alcuni primi costruttori in cui le dichiarazioni potevano avvenire solo nella parte superiore di un blocco. Separare i due ha aiutato a garantire che non si commettesse un errore intrecciando dichiarazioni e codice (ciò era vietato fino a poco tempo fa C89 - C89, Mixing Variable Declarations and Code ). Rendere separato il blocco di dichiarazione potrebbe farti risparmiare un passaggio attraverso il compilatore (non necessariamente una cosa rapida).

K & R è stato scritto nel cuore dell'era "Glass TTY", quando lo schermo di risoluzione standard era di 80 caratteri per 24 righe. Lo spazio bianco era un lusso che di solito si perdeva nel desiderio di mantenere visibili le linee di codice pertinenti.

C'è una dimensione storica nella tua domanda. I computer non avevano sempre uno schermo collegato a loro. Basti pensare alle vecchie macchine da riga di comando / DOS che hanno un numero limitato di righe per schermo. Quindi puoi immaginare che un programmatore volesse vedere più codice possibile in una sola volta.

Inoltre con teletypewriter, ecc. non si può nemmeno essere sicuri di avere uno schermo. Le righe vuote erano uno spreco.