Perché dobbiamo menzionare il tipo di dati della variabile in C

Di solito in C, dobbiamo dire al computer il tipo di dati nella dichiarazione variabile. Ad esempio nel seguente programma, voglio stampare la somma di due numeri in virgola mobile X e Y.

#include<stdio.h>
main()
{
  float X=5.2;
  float Y=5.1;
  float Z;
  Z=Y+X;
  printf("%f",Z);

}

Ho dovuto dire al compilatore il tipo di variabile X.

• Il compilatore non può determinare il tipo da Xsolo?

Sì, posso farlo se lo faccio:

#define X 5.2

Ora posso scrivere il mio programma senza dire al compilatore il tipo di Xcome:

#include<stdio.h>
#define X 5.2
main()
{
  float Y=5.1;
  float Z;
  Z=Y+X;
  printf("%f",Z);

}  

Quindi vediamo che il linguaggio C ha un qualche tipo di funzionalità, usando la quale può determinare il tipo di dati da solo. Nel mio caso ha determinato che Xè di tipo float.

• Perché dobbiamo menzionare il tipo di dati, quando dichiariamo qualcosa in main ()? Perché il compilatore non può determinare da solo il tipo di dati di una variabile main()come fa #define?

Stai confrontando le dichiarazioni delle variabili con #defines, che non è corretto. Con a #define, si crea una mappatura tra un identificatore e uno snippet di codice sorgente. Il preprocessore C sostituirà quindi letteralmente qualsiasi occorrenza di quell'identificatore con lo snippet fornito. scrittura

#define FOO 40 + 2
int foos = FOO + FOO * FOO;

finisce per essere la stessa cosa per il compilatore della scrittura

int foos = 40 + 2 + 40 + 2 * 40 + 2;

Pensalo come copia e incolla automatizzato.

Inoltre, le variabili normali possono essere riassegnate, mentre una macro creata con #definenon può (sebbene sia possibile riprogrammarla #define). L'espressione FOO = 7sarebbe un errore del compilatore, dal momento che non possiamo assegnare a "rvalues": 40 + 2 = 7è illegale.

Quindi, perché abbiamo bisogno dei tipi? Apparentemente alcune lingue si liberano di tipi, questo è particolarmente comune nei linguaggi di scripting. Tuttavia, di solito hanno qualcosa chiamato "tipizzazione dinamica" in cui le variabili non hanno tipi fissi, ma i valori hanno. Mentre questo è molto più flessibile, è anche meno performante. A C piacciono le prestazioni, quindi ha un concetto molto semplice ed efficiente di variabili:

C'è un tratto di memoria chiamato "stack". Ogni variabile locale corrisponde a un'area nello stack. Ora la domanda è: quanti byte deve avere questa area? In C, ogni tipo ha una dimensione ben definita che puoi interrogare tramite sizeof(type). Il compilatore deve conoscere il tipo di ogni variabile in modo da poter riservare la quantità corretta di spazio nello stack.

Perché le costanti create con non #definerichiedono un'annotazione di tipo? Non sono memorizzati nello stack. #defineCrea invece frammenti riutilizzabili di codice sorgente in modo leggermente più gestibile rispetto a copia e incolla. I letterali nel codice sorgente come "foo"o 42.87sono archiviati dal compilatore in linea come istruzioni speciali o in una sezione di dati separata del file binario risultante.

Tuttavia, i letterali hanno tipi. Una stringa letterale è a char *. 42è un intma può essere utilizzato anche per tipi più brevi (restringimento della conversione). 42.8sarebbe un double. Se hai un valore letterale e desideri che abbia un tipo diverso (ad esempio per creare 42.8un float, o 42un unsigned long int), puoi usare i suffissi: una lettera dopo il valore letterale che modifica il modo in cui il compilatore tratta quel valore letterale. Nel nostro caso, potremmo dire 42.8fo 42ul.

Alcune lingue hanno la tipizzazione statica come in C, ma le annotazioni del tipo sono opzionali. Esempi sono ML, Haskell, Scala, C #, C ++ 11 e Go. Come funziona? Magia? No, questo si chiama "inferenza di tipo". In C # and Go, il compilatore esamina il lato destro di un compito e ne deduce il tipo. Questo è abbastanza semplice se il lato destro è letterale come 42ul. Quindi è ovvio quale dovrebbe essere il tipo di variabile. Altre lingue hanno anche algoritmi più complessi che tengono conto del modo in cui viene utilizzata una variabile. Ad esempio, se non lo fai x/2, xnon può essere una stringa ma deve avere un tipo numerico.

X nel secondo esempio non è mai un float. Si chiama macro, sostituisce il valore di macro definito 'X' nell'origine con il valore. Un articolo leggibile su #define è qui .

Nel caso del codice fornito, prima della compilazione il preprocessore modifica il codice

Z=Y+X;

per

Z=Y+5.2;

e questo è ciò che viene compilato.

Ciò significa che puoi anche sostituire quei "valori" con un codice simile

#define X sqrt(Y)

o anche

#define X Y

La risposta breve è che C ha bisogno di tipi a causa della storia / che rappresenta l'hardware.

Storia: C è stato sviluppato nei primi anni '70 e inteso come linguaggio per la programmazione dei sistemi. Il codice è idealmente veloce e sfrutta al meglio le capacità dell'hardware.

Sarebbe stato possibile interferire con i tipi in fase di compilazione, ma i tempi di compilazione già lenti sarebbero aumentati (fare riferimento al fumetto "compilazione" di XKCD. Questo si applicava a "ciao mondo" per almeno 10 anni dopo la pubblicazione di C ). L'inferenza dei tipi in fase di esecuzione non avrebbe adattato gli obiettivi della programmazione dei sistemi. L'inferenza di runtime richiede un'ulteriore libreria di runtime. C è arrivato molto prima del primo PC. Che aveva 256 RAM. Non gigabyte o megabyte ma Kilobyte.

Nel tuo esempio, se ometti i tipi

   X=5.2;
   Y=5.1;

   Z=Y+X;

Quindi il compilatore avrebbe potuto felicemente capire che X & Y sono float e rendere Z lo stesso. In effetti, un compilatore moderno potrebbe anche capire che X & Y non sono necessari e impostare Z su 10.3.

Supponiamo che il calcolo sia incorporato in una funzione. Lo scrittore di funzioni potrebbe voler utilizzare la propria conoscenza dell'hardware o il problema da risolvere.

Un doppio sarebbe più appropriato di un galleggiante? Richiede più memoria ed è più lento ma la precisione del risultato sarebbe maggiore.

Forse il valore di ritorno della funzione potrebbe essere int (o lungo) perché i decimali non erano importanti, sebbene la conversione da float a int non sia priva di costi.

Il valore di ritorno potrebbe anche essere reso doppio garantendo che float + float non trabocchi.

Tutte queste domande sembrano inutili per la stragrande maggioranza del codice scritto oggi, ma erano vitali quando veniva prodotto C.

C non ha un'inferenza di tipo (questo è ciò che viene chiamato quando un compilatore indovina il tipo di una variabile per te) perché è vecchio. È stato sviluppato nei primi anni '70

Molte lingue più recenti hanno sistemi che ti consentono di utilizzare le variabili senza specificarne il tipo (ruby, javascript, python, ecc.)