int Funzione()=0;

non l'ho mai visto (ma magari esiste non lo so).

forse ti riferisci a

codice:
class Classe
{
    virtual int Funzione()=0;
}
In questo caso si dice che la classe Classe è una classe astratta (in java sarebbe avresti scritto abstract invece di virtual ... = 0) ovvero non può essere istanziata.

Quando crei un metodo virtuale il compilatore fa in modo di utilizzare sempre il codice overridato della classe derivata a cui appartiene l'istanza dell'oggetto, anche se tramite un casting è stato ridotto ad un tipo base; per implementare questo comportamento esiste un certo "costo" a runtime; un codice inserito dal compilatore controlla su un'apposita tabella (v-table) associata all'oggetto qual'è il puntatore alla funzione corretta da richiamare, la risoluzione a differenza delle altre funzioni membro non avviene quindi staticamente ma dinamicamente a runtime.

Se il metodo oltre ad essere virtuale è anche puro, significa che le classi derivate devono implementare tutti i metodi virtuali puri per potere essere istanziabili.

Quindi se hai una funzione che prende una classe base come parametro e sai che questa funzione esegue un metodo virtual sei sicuro che verrà eseguito il codice giusto per quella determinata istanza.

esempio
codice:
class forma
{
   virtual double Area()=0;
};

class rettangolo
{....
   double Area(){return base * altezza;}
};

class quadrato : public rettangolo{
  ...
double Area(){return base * base ;}

};

void stampaArea(forma &f)
{
   cout << f.Area(); //controlla qual'è l'istanza di f ed esegue
                     // il metodo corretto a seconda che sia 
                     //rettangolo o quadrato
}

....
FUNZIONI MEMBRO COSTANTI
codice:
class C
{
 ...
char *buffer;
char *pCurrentChar;
public:
   char Char(void) const{ return *pCurrentChar;} 
   char Next(void){ return ++pCurrentChar,*pCurrentChar;} 
...
};
Per quanto riguarda la definizione di una funzione costante, significa che stai dichiarando che questa funzione non modifica i dati membro.

Cio permette al compilatore di lasciarti usare questo metodo anche se il tuo oggetto è dichiarato costante, ad esempio

const C classe;
C.Char(); //legale
C.Next(); //illegale perchè l'oggetto è const e Next non è costante


NB
Queste definizioni che ho dato non sono rigorose tecnicamente, se sei incuriosito prendi un buon libro sul C++ (ce ne sono pochi titoli, se cerchi sul forum trovi diverse discussioni a riguardo).