[c++]contare i giorni...

[moritzplatz]

sto provando a fare un programma che conti i giorni tra due date....
sono arrivato a questo punto
codice:

#include <iostream>  
using namespace std;
/////////////////////////////////////////////////
//prototipi/////////////////////////////////////
////////////////////////////////////////////////
bool bisestile(int a);
 int bisinint(int a,int b);
 bool prima0(int gg,int mm, int aa,int gg1, int mm1, int aa1);
 int totgiorni(int gg,int mm,int aa);
 

int main(){ 

int gg,mm,aa; //variabili della prima data (giorni, mesi, anni)
int gg1,mm1,aa1; //variabili della seconda data (giorni, mesi, anni)

int giornitot0,giornitot1; //totale giorni dall'anno 0 della prima e della seconda data

cout<<"Inserire due date per conoscere il numero di giorni tra di esse"<<endl;

 //l'inserimento delle date 
cin>>gg; cout<<"/"; 
cin>>mm; cout<<"/"; 
cin>>aa; cout<<endl;
cin>>gg1; cout<<"/"; 
cin>>mm1; cout<<"/"; 
cin>>aa1;

//la parte che dovrebbe stampare il numero di giorni dall'anno 0 della prima data 

cout<< totgiorni(gg,mm,aa); 

 return 0; 
}
/////////////////////////////////////// // 
le funzioni 
///////////////////////////////////////

//è un anno bisestile??? 
bool bisestile(int a){     
if((a % 4 == 0 && a % 100 != 0) || a % 400 == 0) return true;    
 else return false; } 

//quanti anni bisestili ci sono in quell'intervallo 
int bisinint(int a,int b){    
 int numbis=0;     
if (a<b){while(a<b)    
if (bisestile (a)==true) numbis=numbis+1;   
  else a++;        
 }        
 else if (a==b){            
 if (bisestile(a)==true) numbis=1;
             else numbis=0;
}               
else if (a>b) {while(a>b)     
if (bisestile (a)==true) numbis=numbis+1;
     else b++;  
       }  
} 

 //quale delle due date è prima??? 
bool prima0(int gg,int mm, int aa,int gg1, int mm1, int aa1){     
if (aa1<aa) return true;     
else if (aa1>aa) return false;     
else if (aa1==aa) {         
if (mm1<mm) return true;         
else if (mm1>mm) return false;         
else if (mm1==mm){             
if (gg1<gg) return true;            
 else if (gg1>gg) return false;             
else if (gg1==gg) cout<<"Mi dispiace ma le due date sono uguali"<<endl;         
}     
}
 }  

//quanti giorni dall'anno 0??
 int totgiorni(int gg,int mm,int aa){ int giorninelmese; 
if (mm==1) giorninelmese=31; 
else if (mm==2) giorninelmese = 59; 
else if (mm==3) giorninelmese = 90; 
else if (mm==4) giorninelmese = 120; 
else if (mm==5) giorninelmese = 151;
 else if (mm==6) giorninelmese = 181; 
else if (mm==7) giorninelmese = 212;
 else if (mm==8) giorninelmese = 243; 
else if (mm==9) giorninelmese = 273; 
else if (mm==10) giorninelmese = 304; 
else if (mm==11) giorninelmese = 334; 
else if (mm==12) giorninelmese = 365;
 return gg + (giorninelmese-gg) + ((aa-bisinint(0,aa)*365)+bisinint(0,aa)*366); }

dopo aver inserito le due date però si ferma mentre mi dovrebbe stampare i giorni dall'anno zero alla prima data in modo che dopo faccio la stessa cosa con la seconda data, li sottraggo e... il gioco è fatto !!
qualche consiglio o magari se mi fate vedere qualche errore grossolano che non ho visto....
grazie a tutti
ciao

[DanieleC88]

Originariamente inviato da moritzplatz

EDIT: per rendere leggibile il codice come faccio a non farlo stare su una sola riga???

Magari andando a capo? Scritto così mi pare arabo, onestamente...

[moritzplatz]

ok ora lo ho modificato
è più comprensibile?

[DanieleC88]

Non tanto, ma cerco di decifrare un po'.

A parte alcune cose riguardanti lo "stile", che non ti correggo qui perché sarebbe troppo lungo (se ti interessa, cerca delle vecchie discussioni riguardanti lo stile di programmazione in cui è intervenuto l'utente fek: sono davvero un'ottima lettura, se le riesco a ritrovare te le linko), ci sono delle cose che non capisco:

return gg + (giorninelmese-gg) + ((aa-bisinint(0,aa)*365)+bisinint(0,aa)*366); }

Quel gg + giorninelmese - gg è, matematicamente, come fare a + b - a che equivale al solo b. Quindi giorninelmese è l'unica cosa che venga aggiunta.
Poi: ((aa-bisinint(0,aa)*365)+bisinint(0,aa)*366) è ok come ragionamento, direi, ma se noti, tu stai chiamando la stessa funzione per ben due volte, dandole gli stessi parametri: ovviamente ti darà gli stessi risultati ad ogni chiamata, quindi puoi salvare in una variabile il risultato e poi sostituire alla chiamata della funzione la sola variabile, guadagnandoci in velocità.
Ancora meglio: puoi notare che tutti gli anni sono costituiti da 365 giorni, mentre quelli bisestili ne hanno uno in più. Allora puoi semplicemente sommare il numero di "giorni bisestili" in eccedenza: (anno * 365) + bisestili(0, anno).

Altra cosa che mi lascia un po' "perplesso" è la funzione prima0(). A parte che logicamente non credo sia un "errore" se le due date sono uguali: alla funzione tu chiedi "la data 0 viene prima della data 1?", dove la risposta, se le date sono uguali, è semplicemente "falso". E poi mi sembra che venga restituito un risultato opposto a quello atteso: ovvero, restituisci "falso" se la prima data è precedente alla seconda, "vero" per il contrario. In più, se le date sono uguali, non restituisci alcun valore: ma la tua non è una funzione void, devi restituire qualcosa. Anzi, è strano che il compilatore non ti abbia messo in guardia: se usi gcc, attiva sempre tutti i warning.

A parte questi errori più o meno credo debba "funzionare", ovvero, ti deve almeno stampare un numero. Prova a rendere più esplicita la stampa:

cout << "Il numero di giorni trascorsi dall'anno zero sembra essere: " << totgiorni(gg, mm, aa) << "." << endl;

ciao

[moritzplatz]

grazie mille!
ho modificato come mi hai detto ma non mi scrive nulla.....
ora il programma è cosi:

#include <iostream>

using namespace std;
bool bisestile(int a);
int bisinint(int a,int b);
bool prima0(int gg,int mm, int aa,int gg1, int mm1, int aa1);
int totgiorni(int gg,int mm,int aa);
int main(){
int gg,mm,aa;
int gg1,mm1,aa1;
int giornitot0,giornitot1;
cout<<"Inserire due date per conoscere il numero di giorni tra di esse"<<endl;
//l'inserimento delle date
cin>>gg;
cout<<"/";
cin>>mm;
cout<<"/";
cin>>aa;
cout<<endl;
cin>>gg1;
cout<<"/";
cin>>mm1;
cout<<"/";
cin>>aa1;
cout << "Il numero di giorni trascorsi dall'anno zero sembra essere: " << totgiorni(gg, mm, aa) << "." << endl;
 return 0;
}

///////////////////////////////////////
// le funzioni
///////////////////////////////////////
//è un anno bisestile???
bool bisestile(int a){
    if((a % 4 == 0 && a % 100 != 0) || a % 400 == 0) return true;
    else return false;
}

//quanti anni bisestili ci sono in quell'intervallo
int bisinint(int a,int b){
    int numbis=0;
    if (a<b){while(a<b)
    if (bisestile (a)==true) numbis=numbis+1;
    else a++;
        }
        else if (a==b){
            if (bisestile(a)==true) numbis=1;
            else numbis=0;}
              else if (a>b) {while(a>b)
    if (bisestile (a)==true) numbis=numbis+1;
    else b++;
        }

}

//quale delle due date è prima???
bool prima0(int gg,int mm, int aa,int gg1, int mm1, int aa1){
    if (aa1<aa) return true;
    else if (aa1>aa) return false;
    else if (aa1==aa) {
        if (mm1<mm) return true;
        else if (mm1>mm) return false;
        else if (mm1==mm){
            if (gg1<gg) return true;
            else if (gg1>gg) return false;
            else if (gg1==gg) cout<<"Mi dispiace ma le due date sono uguali"<<endl;
        }
    }
}

//quanti giorni dall'anno 0??
int totgiorni(int gg,int mm,int aa){
int giorninelmese;
if (mm==1) giorninelmese=31;
else if (mm==2) giorninelmese = 59;
else if (mm==3) giorninelmese = 90;
else if (mm==4) giorninelmese = 120;
else if (mm==5) giorninelmese = 151;
else if (mm==6) giorninelmese = 181;
else if (mm==7) giorninelmese = 212;
else if (mm==8) giorninelmese = 243;
else if (mm==9) giorninelmese = 273;
else if (mm==10) giorninelmese = 304;
else if (mm==11) giorninelmese = 334;
else if (mm==12) giorninelmese = 365;
return (giorninelmese + ((aa-bisinint(0,aa)*365)+bisinint(0,aa)*366));
}

parte, mi fa inserire i numeri e poi non mi dice nulla e si ferma...

[DanieleC88]

Ehm a dire il vero io non vedo parecchia differenza da prima!

Comunque, una cosa che devi controllare è che la funzione totgiorni() riceva mm compreso tra 1 e 12 inclusi: se ciò non dovesse avvenire, giorninelmese a quanto sarebbe uguale? Inizializzala a zero.
In più, cosa ben più "grave" a livello logico, se la data fa riferimento ad un giorno di gennaio, in questo modo aggiungi subito 31 giorni a giorninelmese (e così via), che saranno poi aggiunti al risultato finale. Invece io direi di chiamare la variabile giornitrascorsi e aggiungere solo il numero di giorni trascorsi dall'inizio dell'anno al mese appena precedente, e al risultato finale potrai sommare il giorno del mese attuale senza altre modifiche.

Il resto delle modifiche importanti, per evitare un paio di errori che vedo ancora adesso, te le avevo segnalate nel post precedente.
Spiegami una cosa, però: che intendi con "non stampa niente"? Dubito che possa fermarsi senza stamparti niente, a meno che non ci siano bug che mandano il programma in crash. Che IDE usi, con quale compilatore e da quale sistema operativo?

ciao

[moritzplatz]

modificato ancora

#include <iostream>

using namespace std;
bool bisestile(int a);
int bisinint(int a,int b);
bool prima0(int gg,int mm, int aa,int gg1, int mm1, int aa1);
int totgiorni(int gg,int mm,int aa);
int main(){
int gg,mm,aa;
int gg1,mm1,aa1;
int giornitot0,giornitot1;
cout<<"Inserire due date per conoscere il numero di giorni tra di esse"<<endl;
//l'inserimento delle date
cin>>gg;
cout<<"/";
cin>>mm;
cout<<"/";
cin>>aa;
cout<<endl;
cin>>gg1;
cout<<"/";
cin>>mm1;
cout<<"/";
cin>>aa1;
cout << "Il numero di giorni trascorsi dall'anno zero sembra essere: " << totgiorni(gg, mm, aa) << "." << endl;
 return 0;
}

///////////////////////////////////////
// le funzioni
///////////////////////////////////////
//è un anno bisestile???
bool bisestile(int a){
    if((a % 4 == 0 && a % 100 != 0) || a % 400 == 0) return true;
    else return false;
}

//quanti anni bisestili ci sono in quell'intervallo
int bisinint(int a,int b){
    int numbis=0;
    if (a<b){while(a<b)
    if (bisestile (a)==true) numbis=numbis+1;
    else a++;
        }
        else if (a==b){
            if (bisestile(a)==true) numbis=1;
            else numbis=0;}
              else if (a>b) {while(a>b)
    if (bisestile (a)==true) numbis=numbis+1;
    else b++;
        }

}

//quale delle due date è prima???
bool prima(int gg,int mm, int aa,int gg1, int mm1, int aa1){
    if (aa1<aa) return false;
    else if (aa1>aa) return true;
    else if (aa1==aa) {
        if (mm1<mm) return false;
        else if (mm1>mm) return true;
        else if (mm1==mm){
            if (gg1<gg) return false;
            else if (gg1>gg) return true;
            else if (gg1==gg) return false;
        }
    }
}

//quanti giorni dall'anno 0??
int totgiorni(int gg,int mm,int aa){
int giorninelmese=0;
if (mm==1) giorninelmese=0;
else if (mm==2) giorninelmese = 31;
else if (mm==3) giorninelmese = 59;
else if (mm==4) giorninelmese = 90;
else if (mm==5) giorninelmese = 120;
else if (mm==6) giorninelmese = 151;
else if (mm==7) giorninelmese = 181;
else if (mm==8) giorninelmese = 212;
else if (mm==9) giorninelmese = 243;
else if (mm==10) giorninelmese = 274;
else if (mm==11) giorninelmese = 304;
else if (mm==12) giorninelmese = 334;
return ((giorninelmese + gg) + (aa*365)*bisinint(0,aa));
}

non stampa niente nel senso che quando inserisco l'ultimo valore (aa1) premo invio e si ferma.
ide: code::blocks 8.02
compilatore: gnu gcc
os: windows xp pro

[DanieleC88]

Ecco, Code::Blocks. Lo sapevo.

È un'IDE che mi piace molto, ma ha un solo grande difetto: se il tuo programma va in crash per qualche motivo, ti si chiude la finestra dell'esecuzione senza segnalarti niente. Avvia il tuo programma con il debugging attivato: al 99% ti va in crash in qualche punto, e potrai scoprire dove, a quel punto possiamo correggere l'errore.

[DanieleC88]

Ah comunque:

return ((giorninelmese + gg) + (aa*365)*bisinint(0,aa));

Questo è scorretto, rileggi quanto avevo scritto: devi aggiungere il numero di anni bisestili (che corrisponde ai giorni in eccedenza).

[moritzplatz]

lo ho fatto partire col debugger mi dice
Registered new type: STL String
Registered new type: STL Vector
Setting breakpoints
Debugger name and version: GNU gdb 6.7.50.20071127
Child process PID: 2264
Program exited with code 030000000472.
Debugger finished with status 0

ma fa le stesse identiche cose di prima...

hai ragione mi ero sbagliato

[moritzplatz]

potrebbe essere questo??

main.cpp|53|warning: control reaches end of non-void function|

main.cpp|68|warning: control reaches end of non-void function|

...

[DanieleC88]

Program exited with code 030000000472.

WTF!!!

Dal momento che tu dai un return 0 al termine della main(), quel valore dovrebbe essere 0... No, c'è decisamente qualcosa che non va.

[DanieleC88]

Be', certo che potrebbe essere, tra l'altro sono cose che ti avevo già segnalato.

Guarda bene che prima() non restituisce un bel niente se per qualche motivo superi tutti quei blocchi if (non dovrebbe poter mai succedere, ma come valore di default in questo caso metti un return false al termine della funzione e fai contento il compilatore).

Allo stesso modo, e qui è ben più grave, bisinint() calcola in numbis gli anni bisestili ma... non li restituisce mai!
Metti un return numbis alla fine della funzione.

[moritzplatz]

#include <iostream>

using namespace std;
bool bisestile(int a);
int bisinint(int a,int b);
bool prima0(int gg,int mm, int aa,int gg1, int mm1, int aa1);
int totgiorni(int gg,int mm,int aa);
int main(){
int gg,mm,aa;
int gg1,mm1,aa1;

cout<<"Inserire due date per conoscere il numero di giorni tra di esse"<<endl;
//l'inserimento delle date
cin>>gg;
cout<<"/";
cin>>mm;
cout<<"/";
cin>>aa;
cout<<endl;
cin>>gg1;
cout<<"/";
cin>>mm1;
cout<<"/";
cin>>aa1;
cout << "Il numero di giorni trascorsi dall'anno zero sembra essere: " << totgiorni(gg, mm, aa) << "." << endl;
 return 0;
}

///////////////////////////////////////
// le funzioni
///////////////////////////////////////
//è un anno bisestile???
bool bisestile(int a){
    if((a % 4 == 0 && a % 100 != 0) || a % 400 == 0) return true;
    else return false;
}

//quanti anni bisestili ci sono in quell'intervallo
int bisinint(int a,int b){
    int numbis=0;
    if (a<b){while(a<b)
    if (bisestile (a)==true) numbis=numbis+1;
    else a++;
        }
        else if (a==b){
            if (bisestile(a)==true) numbis=1;
            else numbis=0;}
              else if (a>b) {while(a>b)
    if (bisestile (a)==true) numbis=numbis+1;
    else b++;
        }
return numbis;
}

//quale delle due date è prima???
bool prima(int gg,int mm, int aa,int gg1, int mm1, int aa1){
    if (aa1<aa) return false;
    else if (aa1>aa) return true;
    else if (aa1==aa) {
        if (mm1<mm) return false;
        else if (mm1>mm) return true;
        else if (mm1==mm){
            if (gg1<gg) return false;
            else if (gg1>gg) return true;
            else if (gg1==gg) return false;

        }
    }
return false;
}

//quanti giorni dall'anno 0??
int totgiorni(int gg,int mm,int aa){
int giorninelmese=0;
if (mm==1) giorninelmese=0;
else if (mm==2) giorninelmese = 31;
else if (mm==3) giorninelmese = 59;
else if (mm==4) giorninelmese = 90;
else if (mm==5) giorninelmese = 120;
else if (mm==6) giorninelmese = 151;
else if (mm==7) giorninelmese = 181;
else if (mm==8) giorninelmese = 212;
else if (mm==9) giorninelmese = 243;
else if (mm==10) giorninelmese = 274;
else if (mm==11) giorninelmese = 304;
else if (mm==12) giorninelmese = 334;
return ((giorninelmese + gg) + (aa*365)+bisinint(0,aa));
}

ok ho modificato come mi hai detto e ora non mi da più warning...
ma perchè non vuole funzionare!!!

[DanieleC88]

Aspetta, questa mi sembra grave:

    if (a<b){while(a<b)
    if (bisestile (a)==true) numbis=numbis+1;
    else a++;
        }

In pratica non appena incontri un anno bisestile... smetti di incrementare la a e ripeti il controllo sempre sullo stesso anno?

Io direi di fare così:

/* Queste due macro mettile nell'intestazione del file, sotto gli #include, per separarle un po' dal codice */
#define min(a,b) (((a) < (b)) ? (a) : (b))
#define Max(a,b) (((a) < (b)) ? (b) : (a))

int bisinint(int a, int b)
{
  int first = min(a, b);
  int second = Max(a, b);
  int result = 0;

  for (int x = first; x <= second; ++x)
  {
    if (bisestile(x))
    {
      ++result;
    }
  }
  return result;
}

In questo modo consideri tutti i casi in un ciclo solo ed eviti di incrementare infinitamente quella variabile.

[moritzplatz]

grazie mille ora restituisce il numero dei giorni
ecco il programma in versione quasi definitiva...

#include <iostream>
#define min(a,b) (((a) < (b)) ? (a) : (b))
#define Max(a,b) (((a) < (b)) ? (b) : (a))

using namespace std;
bool bisestile(int a);
int bisinint(int a,int b);
bool prima(int gg,int mm, int aa,int gg1, int mm1, int aa1);
int totgiorni(int gg,int mm,int aa);
int main(){
int giorni;
int gg,mm,aa;
int gg1,mm1,aa1;
cout<<"Inserire due date per conoscere il numero di giorni tra di esse"<<endl;
//l'inserimento delle date
cin>>gg;
cout<<"/";
cin>>mm;
cout<<"/";
cin>>aa;
cout<<endl;
cin>>gg1;
cout<<"/";
cin>>mm1;
cout<<"/";
cin>>aa1;
if (prima(gg,mm,aa,gg1,mm1,aa1)==true) giorni=totgiorni(gg1, mm1, aa1)-totgiorni(gg, mm, aa);
else giorni=totgiorni(gg, mm, aa)-totgiorni(gg1, mm1, aa1);
cout << "Il numero di giorni trascorsi dall'anno zero sembra essere: " << totgiorni(gg, mm, aa) << "." << endl;
cout <<"Il numero di giorni trascorsi dall'anno zero sembra essere: " << totgiorni(gg1, mm1, aa1) << "." << endl;
cout <<"Il numero di giorni trascorsi tra le due date sembra essere: " << giorni << "." << endl;
 return 0;
}

///////////////////////////////////////
// le funzioni
///////////////////////////////////////
//è un anno bisestile???
bool bisestile(int a){
    if((a % 4 == 0 && a % 100 != 0) || a % 400 == 0) return true;
    else return false;
}

//quanti anni bisestili ci sono in quell'intervallo
int bisinint(int a, int b)
{
  int first = min(a, b);
  int second = Max(a, b);
  int result = 0;

  for (int x = first; x <= second; ++x)
  {
    if (bisestile(x))
    {
      ++result;
    }
  }
  return result;
}
//quale delle due date è prima???
bool prima(int gg,int mm, int aa,int gg1, int mm1, int aa1){
    if (aa1<aa) return false;
    else if (aa1>aa) return true;
    else if (aa1==aa) {
        if (mm1<mm) return false;
        else if (mm1>mm) return true;
        else if (mm1==mm){
            if (gg1<gg) return false;
            else if (gg1>gg) return true;
            else if (gg1==gg) return false;

        }
    }
return false;
}

//quanti giorni dall'anno 0??
int totgiorni(int gg,int mm,int aa){
int giorninelmese=0;
if (mm==1) giorninelmese=0;
else if (mm==2) giorninelmese = 31;
else if (mm==3) giorninelmese = 59;
else if (mm==4) giorninelmese = 90;
else if (mm==5) giorninelmese = 120;
else if (mm==6) giorninelmese = 151;
else if (mm==7) giorninelmese = 181;
else if (mm==8) giorninelmese = 212;
else if (mm==9) giorninelmese = 243;
else if (mm==10) giorninelmese = 274;
else if (mm==11) giorninelmese = 304;
else if (mm==12) giorninelmese = 334;
return ((giorninelmese + gg) + (aa*365)+bisinint(0,aa));
}

come funziona quel linguaggio del preprocessore?
grazie ancora
p.s. per incrementare una variabile è indifferente scrivere a++ o ++a?

[DanieleC88]

No, non è la stessa cosa. O, meglio, se il tuo intento è soltanto incrementare, allora sì, non ti fa differenza usare l'una o l'altra sintassi, ma attento a farlo quando vuoi anche leggere il valore della variabile.
La differenza, appunto, sta proprio nel fatto che variabile++ ti restituisce prima il valore e poi incrementa, ++variabile prima incrementa e poi ti restituisce il valore.

Per la questione delle macro del preprocessore è un argomento un po' più delicato, provo a spiegartelo in maniera chiara, ma non contarci troppo.
Quando tu "definisci" un qualcosa tramite le direttive del preprocessore, associ una stringa alfanumerica o un'espressione ad un identificatore: il preprocessore la analizza e la memorizza, così da sostituire all'identificatore la stringa associata, ogni volta che questo viene incontrato nel file.
Un esempio classico: la costante matematica pi greco (la tronco a 3.14 ).

#define PI 3.14

Quando tu dici questo al preprocessore, puoi fare poi riferimento a "PI", anziché 3.14, in tutto il codice seguente:

int circonferenza = (2*PI) * raggio;

Il bello è che puoi fare anche macro che prendono degli argomenti, in modo simile alle funzioni:

#define stampa(messaggio) printf("%s\n", messaggio)

E potrai quindi scrivere:

stampa("Ciao!");

Che sarà sostituito con:

printf("%s\n", "Ciao!");

Ad esempio, prima ho usato una macro come questa:

#define min(a, b) (((a) < (b)) ? (a) : (b))

Che ti può apparire "oscura" a prima vista: niente paura, ti spiego come funziona con un esempio pratico:

int minimo = min(5, 10);

Questa riga verrà tradotta in:

int minimo = (((5) < (10) ? (5) : (10));

Dove ci sono parentesi superflue (per questo caso solamente, leggi più avanti...):

int minimo = ((5 < 10) ? 5 : 10);

Non so se hai mai incontrato la sintassi condizione ? valore1 : valore2, ma significa semplicemente: "È vero che 'condizione'? Se sì, allora restituisci 'valore1', in caso contrario restituisci 'valore2'".
Quindi io lì sto dicendo: "È vero che 5 è minore di 10? Se sì, restituisci 5, in caso contrario restituisci 10". E ovviamente otterrò 5.

Ora che puoi capire come funziona quella macro, devi capire anche che ci sono alcuni problemi relativi al fatto che le macro operano per sostituzione diretta del testo.
Usando la stessa macro di prima, io posso dire:

int x = 3;
int y = 5;
int minimo;

minimo = min(++x, y);

Che valore mi verrà restituito come minimo? E quanto varrà x alla fine? Se hai risposto 3 o 4, hai sbagliato: otterrò 5 come minimo e tale sarà anche il valore della x alla fine del confronto!

Infatti quel codice viene espanso nel seguente:

int x = 3;
int y = 5;
int minimo;

minimo = (((++x) < (y)) ? (++x) : (y));

E come puoi notare, la x viene incrementata ben due volte. Questo non sarebbe successo se avessi definito min() come funzione, anziché come macro.

Un problema simile lo puoi avere anche se non circondi di parentesi i tuoi parametri. Altro piccolo esempio:

#define mul(a, b) (a * b)

Dove ti aspetti che venga restituita la moltiplicazione tra a e b. Ma se io uso:

int risultato = mul(3+2, 6);

Voglio ottenere come risultato (5 * 6) = 30. E invece?

int risultato = (3+2 * 6);

Dal momento che la moltiplicazione è un operatore che ha precedenza superiore a quella della somma, l'espressione verrà valutata così:

int risultato = (3+(2 * 6));

Che mi restituisce 15...

Scusa la lunghezza del post, ma queste cose come vedi sono un po' delicate, se le impari nel modo sbagliato poi ti vengono fuori dei bug che non riesci ad individuare.
ciao

[gugoXX]

Un paio di cose.
Se ascolti i consigli di molti su questo forum, eviti di imparare a programmare il C++ e ti dedichi a linguaggi piu' consoni
Se te l'ha "Detto la maestra", questo e' l'ennesimo caso dimostrazione che il C o C++ non e' il linguaggio migliore da insegnare per primo.
Se non te l'ha detto nessuno e stai provando come autodidatta, ti invito quindi a tentare con qualcosa di simile (C#, ma anche altri)

class Program
{
    static void Main(string[] args)
    {
        Console.Write("Inserire prima data,   formato dd/mm/yyyy :");
        string primastr=Console.ReadLine();
        Console.Write("Inserire Seconda data, formato dd/mm/yyyy :");
        string secondastr = Console.ReadLine();

        DateTime Prima = DateTime.Parse(primastr);
        DateTime Seconda = DateTime.Parse(secondastr);

        TimeSpan ts=Seconda-Prima;

        Console.WriteLine("Il numero di giorni di differenza e' {0}", ts.TotalDays);

        Console.ReadKey();
    }
}

[DanieleC88]

Originariamente inviato da gugoXX

Un paio di cose.
Se ascolti i consigli di molti su questo forum, eviti di imparare a programmare il C++ e ti dedichi a linguaggi piu' consoni
Se te l'ha "Detto la maestra", questo e' l'ennesimo caso dimostrazione che il C o C++ non e' il linguaggio migliore da insegnare per primo.
Se non te l'ha detto nessuno e stai provando come autodidatta, ti invito quindi a tentare con qualcosa di simile (C#, ma anche altri)

Come non essere d'accordo...

Non so se si è notato, ma col mio post precedente, oltre che spiegare come funzionavano macro e simili, ho voluto anche "spaventarlo a fin di bene", per indirizzarlo magari su qualcosa di diverso.

[SnakePlissken]

Per calcolare i giorni trascorsi tra due date potevi usare i giorni giuliani:
un giorno giuliano consente di calcolare il numero di giorni trascorsi a partire da una certa data (qualcosa come il 4mila-e-qualcosa a.C.) fino ad uno specifico giorno-mese-anno. (Vedi anche su Wiki.)
Puoi quindi calcolare i giorni trascorsi tra due date semplicemente come differenza tra i due numeri giuliani delle due date stesse.

Questa è una funzione che ti calcola il numero giuliano di una data passata come argomento (sinceramente non l'ho testato ma dovrebbe funzionare):

long date2jul(int day,int month,int year)
{
    long ctmp, dtmp, mtmp, ytmp;
    if(year < 100)
        year += 1900; // se anno = 82 si assume 1982
    if(year < 1000)
        year += 2000; // se anno = 182 si assume 2182
    if(month > 2) {
        mtmp = (long)(month-3);
        ytmp = (long)year;
    }
    else {
        mtmp = (long)(month+9);
        ytmp = (long)(year-1);
    }
    ctmp = (ytmp/100);
    dtmp = ytmp-(100*ctmp);
    return((146097L*ctmp)/4L+(1461L*dtmp)/4L+(153L*mtmp+2)/5L+1721119L+(long)day);
}

Questo pezzo di codice è tratto dal Tricky C (di Barninga Z), cercalo su internet. Il paragrafo è: "C come Cesare".

Ciao!