Ottima raccolta di tutorials su good-tutorials.com divisi per categorie.

Sito web: http://www.good-tutorials.com/…

Ottimo sito dove poter trovare interessanti tutorial avanazati su programmazione web.

Sito web: http://nettuts.com/…

Queste ottimizzazioni sono facili da applicare a codice gia esistente e in molti casi danno come risultato un aumento della velocita di esecuzione del codice. Ricorda "the fastest code is code that isn’t called" ossia "il codice piu veloce è quello non chiamato".

Usa liste di inizializzazione

Usa sempre liste di inizializzazione nei costruttori. Ad esempio, usa

    TMyClass::TMyClass(const TData &data) : m_Data(data)
    {
    }

piuttosto

    TMyClass::TMyClass(const TData &data)
    {
         m_Data = data;
    }

Senza liste , le variabili del costruttore di default sono invocate prima del costruttore della classe. Con le liste di inizializzazione solo una copia del costruttore è invocata.

Continua a leggere : http://www.custard.org/~andrew/optimize.php …

Obiettivo
In questo articolo tratteremo la struttura dati stack

Lo stack
Uno stack e’ l’opposto di una cosa perche’ utilizza un accesso ai dati di tipo LIFO (last-in,first-out) cioe’
l’ultimo ad entrare e’ il primo ad uscire.
Per pensare fisicamente a uno stack, immaginiamo una pila di piatti. Il primo piatto poggiato sul tavolo sarà
l’ultimo a essere utilizzato mentre l’ultimo piatto sara’ preso per primo.
Per lo stack definiamo due operazioni push e pop che rispettivamente inseriscono e tolgono i dati
dallo stack.

Codice

#include <iostream.h
#include <stdio.h
#include <string.h

class ADT
{
protected :
int modify; // boolean

public :
ADT (int m = 1) : modify(m) { …

Obiettivo
In questo articolo tratteremo un programma che converte una stringa da
formato postfisso a formato infisso attraverso uno stack.

La notazione infissa e postfissa
La notazione infissa e’ il modo comune di scrivere una espressione artimetica cioe’:
(6+2)*5-8/4
Nella notazione postfissa l’ operatore e’ scritto dopo gli operandi
(non servono parentesi ne conoscere la precedenza ed associativita` degli operatori )
L’ espressione precedente puo` essere scritta come:
3 4 + 5 * 8 4 / –
e puo` essere facilmente calcolata per mezzo di una pila usando l’algoritmo che segue.

Codice

#include<stdio.h
#include<stdlib.h
#define MAX 1000
typedef struct pila
{
int elem[MAX];
int top;
}PILA;

PILA *crea();
int push(PILA …

Obiettivo
In questo articolo tratteremo la struttura dati pila

La pila
Una pila e’ l’opposto di una cosa perche’ utilizza un accesso ai dati di tipo LIFO (last-in,first-out) cioe’
l’ultimo ad entrare e’ il primo ad uscire.
Per pensare fisicamente a una pila, immaginiamo una pila di piatti. Il primo piatto poggiato sul tavolo sarà
l’ultimo a essere utilizzato mentre l’ultimo piatto sara’ preso per primo.
Per la pila definiamo due operazioni push e pop che rispettivamente inseriscono e tolgono i dati
dalla pila.

Codice

typedef struct pila
{
int elem;
struct pila *next;
}PILA;

PILA *crea_pila()
{
PILA *p;
p=NULL;
return p;
}

int vuota(PILA *p)
{…

Obiettivo
In questo articolo tratteremo la struttura dati pila

La pila
Una pila e’ l’opposto di una cosa perche’ utilizza un accesso ai dati di tipo LIFO (last-in,first-out) cioe’
l’ultimo ad entrare e’ il primo ad uscire.
Per pensare fisicamente a una pila, immaginiamo una pila di piatti. Il primo piatto poggiato sul tavolo sarà
l’ultimo a essere utilizzato mentre l’ultimo piatto sara’ preso per primo.
Per la pila definiamo due operazioni push e pop che rispettivamente inseriscono e tolgono i dati
dalla pila.

Codice

#define MAX 100

typedef struct pila
{
int elem[MAX];
int top;
}PILA;

PILA *crea_pila()
{
PILA *p;
p=(PILA *)malloc(SIZEOF(PILA));
p-top=0;
return p;
}…

Obiettivo
In questo articolo tratteremo tre algoritmi di ordinamento: inserction sort,
selection sort, bubble sort.

Funzione ausiliaria

FUNZIONE AUSILIARIA CHE SCAMBIA DUE ELEMENTI

void scambia(int a,int b)
{
int tmp;
a=tmp;
a=b;
b=tmp;
}

Selection sort
Il selection sort invece è un metodo che cerca il valore più grande e lo mette alla fine dell’array,
facendo lo scambio fra la posizione con il valore maggiore e l’ultima cella dell’array.

void selection(int a[],int n)
{
int i,j,min;
for(i=0;i<n-1;i++)
{
min=i;
for(j=i+1;j<n;j++)
{
if(a[j]<a[min])min=j;
}
scambia(a[min],a[i])
}
}

Insertion sort
Un esempio di insertion sort occorre nella vita di ogni giorno mentre giochiamo a carte.
Per ordinare le carte nelle tue mani …

Obiettivo
In questo articolo tratteremo come definire una matrice

Codice

#include <iostream.h
#include <stdlib.h

template <class T
class Matrix
{
private :

int rows, cols;
T * element;

public :

Matrix (int r=0, int c=0);
Matrix (int r, int c, T value);
Matrix (const Matrix<T& m);
~Matrix () { delete [] element; }

int Rows () const { return rows; }
int Columns () const { return cols; }

T & operator ( ) (int i, int j) const;
Matrix<T& operator = (const Matrix<T& m);
Matrix<Toperator + () const;
Matrix<Toperator + (const Matrix<T& m) const;
Matrix<Toperator – () const;
Matrix<Toperator – (const …

In questo articolo tratteremo la struttura dati lista doppiamente concatenata

typedef struct lista
{
int dato;
struct lista *next,*prec;
}LISTA;

void insert(LISTA **h,LISTA **t,int d)
{
LISTA *ptr;
ptr=(LISTA *)malloc(sizeof(LISTA));
ptr-dato=d;
ptr-prec=NULL;
ptr-next=*h;
if(*t==NULL)
*h=*t=ptr;
else
{
*h-prec=ptr;
*h=ptr; 
}
}

int cancella(LISTA **h,LISTA **t,int d)
{
LISTA *ptr,*paus;
int trovato=0;
while(*h-dato==d)
{
paus=*h;
*h=*h-next; /*sposto la testa nella prossima locazione e libero la precedente*/
free(paus)
if(*h==NULL) /*se non ci sono piu caselle*/
{
*t=NULL; /*metto la coda a NULL e ritorno 1*/
return trovato=1;
}
else
{
*h-prec=NULL; /*altrimenti la testa è nella nuova casella e faccio puntare il prec*/
trovato=1; …

In questo articolo tratteremo la struttura dati lista

#include <iostream.h
#include <stdio.h
#include <string.h

class Data
{
private :

char buffer [80];

public :

Data () { }
Data (const char * str) { strcpy (buffer, str); }

const char * Get () const { return buffer; }

}; // End class Data

class Node
{
private :

Data * ptr;
Node * next;

public :

Node (Data d)
{
ptr = new Data (d.Get());
next = NULL;
}

~Node() { delete ptr; }

const Data * GetData () const { return ptr; }
Node * GetNext () const { return next; }
void SetNext (Node * x) { next …