Perché non posso causare un errore di seg?

Question

OK per qualsiasi motivo ho problemi a causare un errore di seg. Voglio produrne uno in modo da poter usare gdb per vedere come eseguire il debug di uno. Ho provato entrambi gli esempi dall'articolo the Wikipedia ma nessuno dei due ha funzionato.

Il primo:

char *s = "Hello World!"; 
*s = 'H'; 

E il secondo esempio:

int main(void) 
{ 
    main(); 
} 

EDIT: sto usando Ubutnu 9.10 e g++ come il mio compilatore. Qualcuno può mostrarmi un codice che è garantito per segfault?

Answer 1

E impossable per cercare di affidabilità fanno dereferencing puntatori.
Questo perché il modo in cui l'applicazione gestisce la memoria può variare dal compilatore al compilatore anche attraverso lo stesso compilatore con diverse opzioni (modalità di debug/rilascio gestita in modo diverso).

Che cosa si può fare è sollevare esplicitamente il segfault utilizzando un segnale:

#include <signal.h> 

int main() 
{ 
    raise(SIGSEGV); 
} 

Answer 2

char * ptr = 0; 
*ptr = 1; 

Segmentation fault 

Answer 3

int *hello = NULL; 
printf(*hello); 

oppure si può definire una struct (dire struct HelloWorld)

HelloWorld *myWorld = NULL; 
myWorld->world = "hello"; 

Answer 4

Entrambe le cose che si fanno produrrà "un comportamento indefinito" in C++ (beh, chiamando main() è in realtà esplicitamente vietato). Non vi è alcuna garanzia che causeranno errori di segmentazione - ciò dipenderà da molte cose, ma principalmente dalla piattaforma su cui state lavorando, che non avete specificato.

In effetti, il metodo suggerito di causare un errore di seg può o non può funzionare nel metodo qualsiasi. Questo perché un errore seg è quasi sempre associato al concetto di comportamento non definito del C++.

Answer 5

Un sacco di modi per generare un segfault.

Come dereferenziazione un puntatore errato:

char *s = (char *)0xDEADBEEF; 
*s = 'a'; 

Answer 6

mio sapore di una riga:

*(char *)0 = 0; 

Answer 7

L'articolo di Wikipedia in realtà elenca tre metodi (uno dei quali è un puntatore nullo); perché non hai provato quello?

Per quanto riguarda il motivo per cui i due esempi che hai provato non lo hanno, beh, la risposta corretta, come altri hanno notato, è che è un comportamento indefinito, quindi potrebbe accadere qualsiasi cosa (che include non segfaulting). Ma si potrebbe ipotizzare che il motivo per cui il primo modulo non ha fallito per te è perché il tuo compilatore o il tuo sistema non è sicuro della protezione della memoria. Per quanto riguarda il secondo caso, un compilatore coda-ricorsivo-coscientemente in grado di ottimizzare il ciclo infinitamente ricorsivo main e non finire traboccare lo stack.

Answer 8

Per il primo esempio, il compilatore probabilmente inserisce la stringa nella memoria scrivibile, quindi non vi è alcun errore di seg quando si tenta di cambiarlo.

Per il secondo, il compilatore potrebbe ottimizzare la chiamata o potrebbe ottimizzare la chiamata da solo a un salto (poiché è un tail call), il che significa che lo stack non cresce effettivamente con gli indirizzi di ritorno per ogni chiamata , quindi potresti recitare all'infinito.

Ma come Neil ha menzionato nel suo post, una di queste cose risulta in "comportamento non definito", quindi il codice non è richiesto in fase di esecuzione per generare un errore di seg.

Answer 9

Se si tenta di concatenare due costanti ... ne otterrai uno ...almeno è un modo semplice ...

strcat ("a", "b");

=)

Answer 10

segfault più breve mai:

*(int*)0=0;