Terminologia: dichiarazione avanti rispetto a funzione Prototipo

Question

Per me questi termini sono essenzialmente sinonimi quando si utilizza il linguaggio di programmazione C. In pratica, potrei preferire la "forward statement" per i prototipi in-file rispetto al "prototipo di funzione" per i prototipi inclusi tramite un file di intestazione. Ma anche quella è una distinzione artificiale quando si considera ciò che accade dopo la pre-elaborazione. Forse mi manca qualcosa.

C'è un consenso per quando utilizzare un termine rispetto all'altro?

Answer 1

IMO quelli non sono realmente sinonimi. Per me "prototipo di funzione" fare riferimento al nome della funzione e ai suoi parametri 'e tipi di ritorno. Non si applica solo a ciò che chiamate "forward statement". Tutte le funzioni hanno un prototipo.

Abbiamo più spesso fare la differenza tra una funzione dichiarazione e la corrispondente definizione.

Answer 2

Io uso il termine di dichiarazione anticipata per il seguente tipo di dichiarazione struct con una definizione.

struct Foo; 

Una dichiarazione di funzione non deve essere un prototipo, per la compatibilità con pre-1989 (K & R) C.

char *foo(); // NOT the same as char *foo(void) 

Answer 3

L'unico concetto in C Sono consapevole è la distinzione tra dichiarazione e definizione. Un prototipo è una dichiarazione e può accadere dovunque, in qualsiasi momento e la definizione che è l'effettiva implementazione od l'oggetto dato. con questo concetto, non c'è nulla che si chiami forward forward, c'è solo un ordine di dichiarazione.

Answer 4

Non so se v'è un consenso, ma penso che il modo più pulito per farlo sarebbe:

• Luogo tutte le dichiarazioni nei file di intestazione, non in file .c sorgente o. (Credo che si intende quando si dice dichiarazione dichiarazione anticipata.)
• posto tutte le definizioni nei file sorgenti

non mi piace per inserire le dichiarazioni nei file perché si può avere dichiarazioni contrastanti senza errori in C, che può causare segfaults, per esempio: se ac ha

int foo(char *str_one, char *str_two, char *str_three); 

e bc ha

int foo(char *str_one, char *str_two); 

non sarà possibile ottenere avvisi né errori, e le chiamate fatte a foo() da b.c non collocheranno tutti i parametri nello stack dove dovrebbero essere, cioè foo() prenderà semplicemente qualcosa dallo stack e lo tratterà come str_three, probabilmente portando a un segfault. Quindi per me, le dichiarazioni vanno ai file header e le definizioni vanno ai file sorgente.

Answer 5

Il termine "prototipo" si riferisce a una sintassi specifica della dichiarazione; nello specifico, che il numero e i tipi di parametri della funzione compaiano nella dichiarazione.Data una definizione di funzione di

int foo(int a, char *b) {...} 

si può avere uno dei seguenti dichiarazioni:

int foo();    // a declaration, but not a prototype 
int foo(a, b);   // a declaration, but not a prototype 
int foo(int, char *);  // a declaration and a prototype 
int foo(int a, char *b); // a declaration and a prototype