Newsgroup: it.comp.lang.c++
Titolo: Domanda da dilettante

Praticamente mi sto appena avvicinando al linguaggio C+ + e per ora ho solo
copiato dei piccoli programmi presi da un libro.Ho notato perň che quando li
eseguo la finestra dos si chiude dopo aver eseguito il programma senza darmi
il tempo di visualizzare il risultato.La mia domanda č: come faccio a fare
in modo che dopo l'esecuzione del programma la finestra rimanga aperta?
Sicuramente molti di voi potranno dare una mano a un novellino come me.
P.S. come compilatore uso Dev-C + +

in modo che dopo l'esecuzione del programma la finestra rimanga aperta?
Mettici una bella attesa della pressione di un tasto ! ;)

Impara a come scrivere i risultati in un tuo file con formato testo per
visualizzarli con comodo a programma terminato.
Come semplice esempio per un risultato intero, prova a chiamare una funzione
del genere passandogli il valore da visualizzare.
#include <fstream.h>
void visualizza_risultato(int res)
{
    ofstream file_risultato("res.txt");
    cout << "Risultato:  " << res << endl;
    file_risultato.close();
}
void main()
{
    int a, b, tot;
    a = 10;
    b = 20;
    tot = a + b;
    visualizza_risultato(tot);
    // a programma terminato apri col notepad o con un qualsiasi
    // visualizzatore di file di testo il file res.txt e controlli il
risultato.
}

 P.S. come compilatore uso Dev-C + +
credo che tu stia sviuppando un progetto consolle. In questo caso un modo per
vedere i risultati e' eseguire il programma invece che debuggarlo: all'uscita
dal main
ti scrivera' "press a kay to continue" bloccando la finestra.

void main()
Ma main() non dovrebbe restituire int ?

Mettici una bella attesa della pressione di un tasto ! ;)
Oppure lanciare l'eseguibile dal prompt di dos.
-------             --------
J  I  G  G  L  Y  P  U  F  F .
-------             --------

argh!....
sorry :(
sono sempre legato al void main(), mi devo ancora abituare a questa "strana"
pratica dell´ int main().
Ma come mai il main deve restituire int anche se poi alla fin fine non gli
facciamo restituire un bel nulla ?
... mi inchino allo standard :)

 in modo che dopo l'esecuzione del programma la finestra rimanga aperta?
#include <conio.h>
....
main()
{
......
getch();
return(0);
}

 facciamo restituire un bel nulla ?
Credo per coerenza con le convenzioni di chiamata del codice di
start-up.
Ma sto cominciando ad avere dei dubbi che lo standard indichi proprio
int come tipo di ritorno.
Qualcuno puo' confermare ?

 Qualcuno puo' confermare ?
Io ho sempre saputo così. Qualcuno ha lo standard sottomano?
EMG

 Qualcuno puo' confermare ?
Si`, lo standard dice int.
Inoltre (caso speciale previsto dallo standard), SOLO per
main(), se manca una istruzione return questo DEVE essere
equivalente alla presenza di un "return 0" (per qualsiasi
altra funzione che torna int, la mancanza di un return
sarebbe invece un errore).  Non so se quest'ultimo dettaglio
sia pienamente implementato dalla maggioranza dei compilatori
di oggi (si tratta ovviamente di una banalita`, ma appunto
per questo la sua implementazione dovrebbe essere molto ma
molto facile); VC++6 mi pare che non lo implementi.
Alex

sarebbe invece un errore).
Ma scrivere in C++ :
main()
{
}
e' legale ? 
Credo di no, vero ? bisogna specificare per forza il tipo di ritorno.
Nel caso di
void main()
{
}
come si comporta il compilatore ? Sostituisce con
int main()
{
    return 0 ; 
}
 
?

 come si comporta il compilatore ? Sostituisce con
Come preferisce; questo programma e` non-compliant e il
compilatore fara` quello che vuole.
Immagino che in pratica la maggior parte dei compilatori
non trattera` main come caso speciale e quindi il piu`
probabile risultato sara` che il programma torna al
codice operativo, al suo completamento, un valore piu`
o meno "casuale", quel che e` rimasto in qualche suo
registro a seconda delle operazioni precedenti, magari
(sempre secondo il compilatore) sempre lo stesso per
certuni, diverso ogni volta per altri.
Un vecchio sistema operativo real-time per un mini della
IBM (peraltro ottimo) considerava ciascuno dei 16 bit
tornati da un programma come una indicazione di una
possibile condizione di errore (di emergenza).
Su questo sistema, dunque, tornando una parola di 16
bit "a caso" ti saresti (come minimo, se il SO girava
in modo "console-per-debug") visto una sfilza di
messaggi molto allarmistici, all'uscita del tuo
programma, che ti segnalavano il rilevamento di errori
gravissimi e terribili -- da "alimentatore guasto, salvare
tutto subito prima che le batterie di backup si
esauriscano!" a "spegnere immediatamente la macchina,
surriscaldamento pericoloso della CPU, pericolo di
incendio!!!".
Se lo stesso programma fosse stato usato in condizioni
di piena operativita` (senza operatore, modalita` non
debug, come e` tipico di un mini per controllo di
processi) sarebbero probabilmente scattati i meccanismi
di shut-down di emergenza, fermando le presse idrauliche
o gli altoforni o i semafori o checche` d'altro quel
computer controllasse.  Non so per certo, non ho infatti
provato:-).  Mentre le sfilze di messaggi da cardiopalma
le ho viste di persona...!-)
Posso solo immaginare la divertente scenetta del
programmatore che ha scritto "void main", provocando
uno spegnimento di altoforno e un danno economico di
alcuni miliardi, a cercare di spiegare come e perche`
queste cosette non hanno poi tanta importanza:-).
Alex

queste cosette non hanno poi tanta importanza:-).
;) grazie per la spiegazione.

 in modo che dopo l'esecuzione del programma la finestra rimanga aperta?


}
Questa é sicuramente la soluzione più comoda per bloccare l'esecuzione
di un programma, ma potrebbe non funzionare nei compilatori che non
supportano la funzione getch(). Io preferisco aggiungere un
cin>>variabile in fondo al listato.


 Io preferisco aggiungere un cin>>variabile in fondo al listato.
Oppure
cin.get();
EMG