Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
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:
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:
Codice sorgente - presumibilmente C/C++
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:
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.
Postato originariamente da __GiReX__: 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:
Codice sorgente - presumibilmente C/C++
..
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.
Ultima modifica effettuata da netarrow il 08/06/2007 alle 22:20
()
Newbie
Messaggi: Iscritto:
Postato alle 2:27
Sabato, 30/06/2007
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?
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..)
Ultima modifica effettuata da netarrow il 30/06/2007 alle 15:54
()
Newbie
Messaggi: Iscritto:
Postato alle 19:21
Sabato, 30/06/2007
Mi sto sempre + convincendo che il mioi libro
"Guida al C++" di Herbert Shildt (Mc Graw-hill)
nella traduzione italiana contenga delle imprecisioni e talvolta degli errori.
Posto qui un listato preso dal libro (scaricabile dal sito produtt)
Codice sorgente - presumibilmente C++
listato 7
// Indicizzazione di un puntatore come un array.
#include <iostream>
#include <cctype>
usingnamespace std;
int main()
{
char str[20]="ciao marco";
char*p;
int i;
p = str;// mette l’indirizzo di str in p
// ora indicizza p come un array
for(i=0; p[i]; i++) p[i]=toupper(p[i]);
cout<< p;// visualizza la stringa
return0;
}
anche qui dunque il puntatore p dovrebbe essere dichiarato come char**