Newsgroup: it.comp.lang.c++
Titolo: c insieme al c++

Ciao!!!
Ho una domanda da fare a voi, ho iniziato a scrivere un programma in c, ma
adesso voglio scrivere in c++, ora la domanda e:
posso semplicemente iniziare a scrivere in c++ o prima devo
convertire il codice precedentemente scritto in c???non so se
e utile per voi nella risposta ma il compilatore che uso e
il gcc del BeOS.
Grazie e CIAO!!!!!


wrote:


il gcc del BeOS.
Tutto il codice C è anche codice C++!
--
Francesco Trotta
http://space.tin.it/computer/ftrotta
Elimina "x_" dal mio indirizzo per mandarmi
un messaggio direttamente

 convertire il codice precedentemente scritto in c???
Normalmente c'č molto poco da convertire nel passaggio da C a C++.
EMG

 si, puoi tranquillamente inserire codice c++ in un programma c
Ovviamente intendevi il contrario. E comunque anche quel
"tranquillamente" va preso un pochino con le pinze.
EMG

 Tutto il codice C è anche codice C++!
Non proprio al 100%.
EMG

 
Non e' esatto. Ci sono alcune differenze:
- dichiarazioni implicite non ammesse
- in C++ le funzioni dichiarate senza argomenti sono considerate funzioni
con 0 argomenti mentre in C sono funzioni con un numero qualunque di
argomenti.
- il C++ le variabili dichiarate 'const' globali al file sono considerate
static mentre in C sono extern
...solo per citarne alcune.
Per evitare problemi, modificare gli header C in modo da dichiararli extern
"C":
#ifdef __cplusplus
extern "C" {
#endif
.....
#ifdef __cplusplus
}
#endif


ICQ #34602650

static mentre in C sono extern
In maniera più corretta: dichiarazioni di una costante globale con lo stesso
nome su file diversi facenti parte dello stesso programma (quindi anche file
di include) provocano un errore in C, ma non in C++. Comunque ciò non mi
impedisce di importare codice C in un programma C++ e avere lo stesso
comportamento.
Un problema potrebbe essere invece che una costante deve essere
necessariamente inizializzata in C++, ma non in C.
Quali sono le altre differenze?


 le interpreti in quel modo.
Quindi secondo te la dichiarazione extern "C" dice al compilatore che il
sorgente č scritto in C e non in C++? Io pensavo si limitasse a
disattivare il name-mangling. Sbaglio?
Ho appena fatto la seguente prova con il DJGPP:
extern "C"
{
    void pippo()
    {
    }
}
int main()
{
    pippo( 1, 2 );
}
Ora, se la tua ipotesi fosse esatta il programma di cui sopra dovrebbe
essere corretto in quanto in C non mettere parametri all'interno delle
parentesi di una dichiarazione di funzione significa che questa ha un
numero variabile di parametri mentre in C++ significa che non ha
parametri. Invece il compilatore mi dą il seguente errore:
too many arguments to function `void pippo()'
EMG

quindi se ho capito bene dovrei fare:
------------------------------
#idfef __cplusplus
extern "C" {
    "CODICE C"
}
#endif
"CODICE C++"
------------------------------
ma non sarebbe #ifndef al posto di #ifdef ???
ciao

 l'utilizzo dei parametri (anche se non necessari).
Guarda che "prototipo" e "dichiarazione" sono la stessa cosa. Non ho
capito cosa intendi dire.
EMG

ma non sarebbe #ifndef al posto di #ifdef ???
No perche` _cplusplus e` definita solo se stai compilando con un
compilatore C++. Per utilizzare #ifndef dovresti anche negare la macro,
ma avresti poi qualche problemino a "organizzare il file"
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------

Schildt, eh? Ecco spiegato l'arcano... :-)
Un'altra vittima... sigh!


 Alberto

 disattivare il name-mangling. Sbaglio?
Non sbagli, ma sbaglio io. Ho detto una stronzata.


capito cosa intendi dire.
Un prototipo è una _definizione_ che non è una _dichiarazione_


 Un prototipo è una _definizione_ che non è una _dichiarazione_
A me non risulta. Io ho sempre saputo che le definizioni sono quelle
per le quali viene riservato spazio in memoria.
Il prototipo dice solo che da qualche parte ci potrebbe essere una
funzione con quella "interfaccia" ma non viene riservato per essa alcuno
spazio in memoria. Se si ha:
#include <stdio.h>
int pippo(int);
int main(void) {
    fprintf(stdout,"topogigio1\n");
    fflush(stdout);
    return 0;
}
compilando (e linkando) con cc -Wall a.c non si ottiene alcun warning.
Mentre se si avesse
#include <stdio.h>
int pippo(int);
int main(void) {
    fprintf(stdout,"topogigio1\n");
    fflush(stdout);
    pippo(2);
    return 0;
}
dopo cc -Wall a.c si otterrebbe
/tmp/cca051891.o: In function `main':
/tmp/cca051891.o(.text+0x25): undefined reference to `pippo'
Cioe` il linker si "innervosisce" perche` non trova da nessuna
parte in memoria la (definizione della) funzione pippo.
Purtroppo non mi ricordo dove l'ho letto, ma giurerei che quello che
ho letto era una cosa del tipo sopra.
Potresti indicare dove hai letto che il prototipo e` una definizione ?
Marco Guidi
 

per le quali viene riservato spazio in memoria.
E' il viceversa. La dichirazione prevede un'istanziazione.
Nel prototipo definisci una funzione che poi dichiari (specificandone il
codice)


Un prototipo è una _definizione_ che non è una _dichiarazione_
Un prototipo e` una semplice dichiarazione e basta... ti dice che esiste
una certa funzione con una certa signature:
int Sum(int a, int b);    // prototipo == semplice dichiarazione
La definizione e` invece data dall'implementazione:
int Sum(int a, int b) {     // questa e` una definizione
  return a+b;


 Un prototipo è una _definizione_ che non è una _dichiarazione_
No. In C/C++ un prototipo è la dichiarazione della funzione. E' però
possibile che venga utilizzata la stessa definizione come dichiarazione
e quindi in quel caso i tre elementi coincidono.
EMG

La definizione e` invece data dall'implementazione:
Ripeto: _e'_ _il_ _contrario_ (o almeno a secondo il libro innominabile:-)
Tanto che _dichiari_ (e non definisci) una variabile globale, locale, ...


 codice)
Mi potresti dire dove hai trovato questa definizione ?
Quella che riportavo io era tratta dai miei appunti dal corso di
Calcolatori Elettronici a.a. 1994-1995 della  Facolta` di Ingegneria
Informatica dell' Universita` di Pisa (ma giurerei di averla letta anche
su qualche libro, anche se non riesco a ricordare quale).
Marco Guidi
 

su qualche libro, anche se non riesco a ricordare quale).
Seguivi il Frosini?
Marco

 Marco
 Si`, pero` la domanda e` piuttosto OT (anche la risposta).
Marco Guidi.
 
 

Tanto che _dichiari_ (e non definisci) una variabile globale, locale, ...
Non te la prendere, ma forse e` meglio che metti via quella specie di
libro (povero albero... sigh!). Scaricati dalla rete il libro di Bruce 
Eckel 
www.bruceeckel.com


su qualche libro, anche se non riesco a ricordare quale).
Sempre sullo Schildt, ma questa volta riportata anche dal mio professore di
Calcolatori Elettronici (però il corso è Ingegneria Elettronica
all'Università di Perugia).


codice)
Una definizione (di funzione) è una specifica dell'implementazione, ovvero si
ottiene quando specifichi un corpo per una funzione. Stroustrup dice:
"una dichiarazione di una funzione fornisce il nome, il tipo del valore
restituito (quando presente) e il numero e i tipi degli argomenti che devono
essere forniti al momento della chiamata della funzione. [...] Una definizione
di funzione è una dichiarazione in cui viene presentato il corpo della
funzione."
extern void swap(int*, int*);        // a declaration
void swap(int* p, int* q)    {        // a definition
    int t= *p;
    *p= *q;
    *q= t;
}
Il C non è così rigido in fatto di dichiarazioni come il C++.
Il prototipo è stata un'aggiunta al C proposta dal comitato di standardizzazione
ISO/ANSI C per rimediare, almeno parzialmente, al sistema di tipi debole che il
linguaggio implementa. Non si tratta assolutamente di una definizione, in quanto
non c'è nessun associazione di una qualche implementazione (leggi corpo).
Non si tratta di uno strumento obbligatorio, come afferma Steve Maguire (Writing
Solid Code): "L'ANSI C richiede i prototipi per le funzioni standard, ma non per
quelle scritte dal programmatore; i prototipi per queste ultime sono opzionali.
[...] l'utilizzo dei prototipi permette di scrivere codice migliore; la ragione
è che lo standard ANSI permette di ottimizzare il codice in base alle
informazioni fornite con i prototipi".
Sicuramente il prototipo è molto più simile a una dichiarazione (la distinzione
potrebbe essere quasi esclusivamente accademica). Io sospetto, comunque, che tu
abbia letto male lo Schildt il quale di C++ non è poi così brillante, ma che
dovrebbe essere molto più a suo agio col C. Nell'omonimo suo libro (C) egli
afferma:
"Lo standard ANSI prevede un passo ulteriore, consentendo di dichiarare il tipo
e il numero degli argomenti della funzione. Questa dichiarazione estesa è detta
prototipo di funzione". In C non c'è l'obbligo di dichiararenè il tipo, nè il
numero dei parametri. Ad esempio, un prototipo non può consentire istanziazioni
implicite (ad int) se manca un tipo da qualche parte, mentre una "normale
dichiarazione" si. Oltre a questa sfumatura, al lato pratico un prototipo non è
diverso da tutte le altre dichiarazioni.
AB
--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Andrea Baruzzo
Via Circonvallazione, 26
Muzzana del Turgnano (UD) - Italy
e-mail: 
andrea....@ud.nettuno.it
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Eckel 
www.bruceeckel.com
Già fatto :-)


Chiedo pubblicamente perdono per aver fatto iniziare questa catena (che non
sembra finire per adesso :-)
Non lo farò mai più :-) (impuntarsi poi su "dichiarare" o "definire": chiedo
ancora scusa (seriamente)).
Comunque, riassumendo per il (povero) Rafa, penso siano tutti d'accordo che,
nonostante le differenze tra C e C++, queste stesse non proibiscono di
portare codice C in C++ ottenendo lo stesso funzionamento. O meglio (riporto
le differenze citate da Alberto Chessa)
- dichiarazioni implicite non ammesse
*Abitudine poco usata (solo nel codice molto vecchio, anche perchè il
prototipo "aiuta" il compilatore nell'individuazione di potenziali warning).
- in C++ le funzioni dichiarate senza argomenti sono considerate funzioni
con 0 argomenti mentre in C sono funzioni con un numero qualunque di
argomenti.
*Vedi precedente (nei prototipi molto spesso riporti anche i parametri
formali)
- il C++ le variabili dichiarate 'const' globali al file sono considerate
static mentre in C sono extern
*Espressa in termini non corretti (meglio: dichiarazioni di una costante
globale con lo stesso nome su file diversi facenti parte dello stesso
programma (quindi anche file di include) provocano un errore in C, ma non in
C++) ma comunque irrilevante perchè pone condizioni più limitanti in C che
in C++.
A rigore il codice C non è codice C++


A rigore il codice C non è codice C++
Ovviamente... ;)


Inoltre possono dare origine ad altri spunti di discussione.
Il fatto č che non si riassumeva la discussione e si continuava sulla linea
del dichiarare-definire (che non ha risolta niente in quanto ognuno č
rimasto con le sue idee)
Ho quindi cercato di fare un riassuntino per evitare messaggi inutili (come
questo:-)


 rimasto con le sue idee)
Non ti offendere ma credo che tu, dopo che te l'abbiamo detto in cento,
ancora non abbia capito cos'è dichiarazione e cosa definizione. Ah, lo
Schildt... :-(
EMG

Schildt... :-(
Ti ringrazio per il pensiero: sei gentilisssssssimo.
Ma di questo non importa niente agli altri e tanto meno a me. Quindi...


 all'interno delle classi.
Si può fare, mi sembra inutile e poco "OOP". (termine da prendere con le
pinze)
O meglio, è un modo di fare "finta" OOP.
Può andare bene per imparare, ma se lo scopo è riutilizzare codice C, si
possono usare i metodi già descritti da altri, se invece si vuole cambiare
modo di programmare passando al C++, è fuorviante.
Sarebbe meglio riprogettare le classi ex novo, se poi qualche metodo può
riutilizzare il codice delle funzioni, tanto meglio...
Non sei d'accordo?
--
Alessandro Monti

 Ma di questo non importa niente agli altri e tanto meno a me. Quindi...
Scusa ma allora perché scrivi su questo newsgroup? Penso che sia normale
partecipare per capire di più sull'argomento. Quindi dovrebbe
interessarti sapere se qualcosa ti è sfuggito. O sbaglio?
EMG