Tips&Tricks

I trucchi del mestiere

Come risolvere equazioni di secondo grado

Una piccola applicazione che si occupa di risolvere equazioni quadratiche del tipo Ax^2 + Bx + C = 0 e che implementa due funzioni specifiche: numRoots(a, b, c) e quadSolve(a, b, c); la prima determina il numero di radici, mentre la seconda si occupa di trovare le radici.

#include 
#include 

/*************************************\
*         numRoots(a, b, c)           *
\*************************************/
int numRoots(int a, int b, int c)
{
  int d = (b * b) - (4 * a * c);
  if (d < 0) return 0;
  if (d == 0) return 1;
  if (d > 0) return 2;
}

/*************************************\
*        quadSolve(a, b, c)           *
\*************************************/
void quadSolve(int a, int b, int c)
{
  double solution1, solution2;
  int d = (b * b) - (4 * a * c);
  int roots = numRoots(a, b, c);
  if (roots == 0) cout<<"There are zero real roots for this function"<<"There is one real root which is: x="<<"There are two real roots which are x="<<"A: ";
  cin>>a;
  cout<<"B: ";
  cin>>b;
  cout<<"C: ";
  cin>>c;
  quadSolve(a, b, c);
}

Come leggere un file riga per riga

Utilizzando le Standard Template Library, questo piccolo codice consente di accedere ad un file e leggerlo riga per riga. Per immagazzinare i dati cos∞ ottenuti viene utilizzato un vettore: ogni riga memorizzata in una cella di questo vettore.

#include 
#include 
#include 
#include 

using namespace std;

int main()
{
     vector  lines;   // store each line in a cell of vector

     ifstream file ("file.dat");
 
     if (file)
     {
	string line;
	while (getline (file, line))
	    lines.push_back (line);
     }

     return 0;
}

Come calcolare il numero di nepero

Utilizzando le serie di Taylor, questo piccolo pezzo di codice si occupa di calcolare il numero di Nepero. Non particolarmente veloce, ha nella semplicitα la sua forza.

#include
using namespace std;
double fact(int);
int round1;
int main()
{
int endround;
int i;
int startround;
int pres;
cout << "startround?";
cin >> startround;
cout << "endround?";
cin >> endround;
cout << "pres?";
cin >> pres;
for (round1=startround; round1<=endround; round1++)
{
double e=0;
for (i=1; i<=round1; i++) 
{
e = e + (1/(fact(i)));
};
cout.precision(pres);
cout << round1;
cout << ". ";
cout << e+1;
cout << "\n";
};
return 0;
}

double fact(int i)
{
double s = 1;
int j;
for (j=1; j<=i; j++) {
s*=j;
};
return s;
}

Come ridurre lo sfarfallio durante il ridimensionamento delle finestre

Come tutti sanno, il messaggio WM_PAINT Φ inviato ad una finestra ogni qual volta si rende necessario ridisegnarla. Dunque, generalmente, scriviamo tutte le istruzioni relative al layout della finestra nell'handler di WM_PAINT, incluse le istruzione relative allo sfondo. Quello che accade in realtα Φ che prima di WM_PAINT Φ inviato il messaggio WM_ERASEBKGND, la cui implementazione di default cancella l'area corrispondente alla finestra con un rettangolo bianco. Per migliorare l'efficienza pu≥ essere utile individuare gli oggetti che non cambiano sullo schermo, il codice che si occupa di disegnare questi oggetti pu≥ essere dunque spostato dall'handler di WM_PAINT a quello di WM_ERASEBKGND, avendo l'accortezza di ritornare un valore diverso da zero per indicare che non Φ pi∙ necessaria la cancellazione riferita a quell'oggetto. Con questa soluzione si riduce la complessitα delle operazioni di disegno di una finestra e si elimina l'effetto di sfarfallio durante lo spostamento ed il ridimensionamento delle finestre.