 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
F. Bugauer
Guest
|
 Posted: Mon May 10, 2004 3:16 pm Post subject: Dereferenzieren von NULL / Standard-Exceptions |
 |
|
Hallo
Ich arbeite erst seit Kurzem unter C++ mit Exceptions und versuche nun
schon einige Stunden, einen Codeabschnitt zum Laufen zu bringen.
Offensichtlich habe ich mir aber etwas falsch überlegt: Ich habe
meinen Denkfehler auf folgendes kleines Beispiel eingeschränkt:
// irgendwo im Code
MyClass * m; // oder auch: MyClass * m = NULL;
try {
m->printList();
}
catch (std::exception & e){
cout << "Exception: " << e.what();
}
Meiner Ansicht nach müsste m-> eine Standardexception auslösen, da
versucht wird, NULL zu dereferenzieren. Leider komme ich aber nicht in
den catch-Teil hinein, das ganze bricht direkt ab.
Ich kann mir kaum vorstellen, dass ich unter c++ jedes Dereferenzieren
manuell überprüfen muss um ggf. eine Exception zu werfen. Leider habe
ich nur sehr wenig zu den Standardexceptions im Netz gefunden und bin
daher auf Eure Hilfe angewiesen.
Wo liegt mein Denkfehler?
Herzlichen Dank im Voraus
Florian
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Stefan Reuther
Guest
|
| Posted: Mon May 10, 2004 4:44 pm Post subject: Re: Dereferenzieren von NULL / Standard-Exceptions |
|
|
F. Bugauer wrote:
| Quote: | MyClass * m; // oder auch: MyClass * m = NULL;
try {
m->printList();
[...]
Meiner Ansicht nach müsste m-> eine Standardexception auslösen, da
versucht wird, NULL zu dereferenzieren.
|
C++ != Java.
Dereferenzieren von NULL hat undefiniertes Verhalten und wirft nur in
den allerseltensten Fällen eine Ausnahme. Du must das testen-und-werfen
schon selber übernehmen.
Stefan
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Martin Winkler
Guest
|
| Posted: Mon May 10, 2004 4:53 pm Post subject: Re: Dereferenzieren von NULL / Standard-Exceptions |
|
|
F. Bugauer schrieb:
| Quote: | Hallo
Ich arbeite erst seit Kurzem unter C++ mit Exceptions und versuche nun
schon einige Stunden, einen Codeabschnitt zum Laufen zu bringen.
Offensichtlich habe ich mir aber etwas falsch überlegt: Ich habe
meinen Denkfehler auf folgendes kleines Beispiel eingeschränkt:
// irgendwo im Code
MyClass * m; // oder auch: MyClass * m = NULL;
try {
m->printList();
}
catch (std::exception & e){
cout << "Exception: " << e.what();
}
Meiner Ansicht nach müsste m-> eine Standardexception auslösen, da
versucht wird, NULL zu dereferenzieren.
|
In Java ja, in C++ nein. In C++ ist das Dereferenzieren eines
Nullpointers nicht erlaubt.
| Quote: | Leider komme ich aber nicht in
den catch-Teil hinein, das ganze bricht direkt ab.
Ich kann mir kaum vorstellen, dass ich unter c++ jedes Dereferenzieren
manuell überprüfen muss um ggf. eine Exception zu werfen. Leider habe
ich nur sehr wenig zu den Standardexceptions im Netz gefunden und bin
daher auf Eure Hilfe angewiesen.
Wo liegt mein Denkfehler?
|
C++ ist nicht Java.
Ansonsten hast du die Dinge ganz richtig verstanden.
Gruß
Martin
--
http://www.jumli.de
http://www.jumlidev.de/forum/
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Torsten Robitzki
Guest
|
| Posted: Mon May 10, 2004 5:06 pm Post subject: Re: Dereferenzieren von NULL / Standard-Exceptions |
|
|
F. Bugauer wrote:
| Quote: | Hallo
Ich arbeite erst seit Kurzem unter C++ mit Exceptions und versuche nun
schon einige Stunden, einen Codeabschnitt zum Laufen zu bringen.
Offensichtlich habe ich mir aber etwas falsch überlegt: Ich habe
meinen Denkfehler auf folgendes kleines Beispiel eingeschränkt:
// irgendwo im Code
MyClass * m; // oder auch: MyClass * m = NULL;
try {
m->printList();
}
catch (std::exception & e){
cout << "Exception: " << e.what();
}
Meiner Ansicht nach müsste m-> eine Standardexception auslösen, da
versucht wird, NULL zu dereferenzieren. Leider komme ich aber nicht in
den catch-Teil hinein, das ganze bricht direkt ab.
|
Das ist keine Ausnahme, sondern ein Fehler in Deinem Programm. Das
passiert, wenn Du einen null Zeiger dereferenzierst ist nicht definiert
und sollte damit immer vermieden werden.
| Quote: | Ich kann mir kaum vorstellen, dass ich unter c++ jedes Dereferenzieren
manuell überprüfen muss um ggf. eine Exception zu werfen.
|
Muß man nicht, wenn wenn man weis, das bei einem Fehlerfreien Programm,
ein Zeiger an einer bestimmten Stelle nicht null sein kann. Um zu
dokumentieren, das eine Zeiger an einer bestimmten Stelle nicht null
sein kann, kann man asserts ganz gut verwenden.
| Quote: | Leider habe
ich nur sehr wenig zu den Standardexceptions im Netz gefunden und bin
daher auf Eure Hilfe angewiesen.
Wo liegt mein Denkfehler?
|
Darin, das jeder ein Problem mit Zeigern hat. Entweder ich habe welche,
die auch mal null sein können, dann muß ich das Prüfen und dann ist der
Wert null auch keine Ausnahme oder ich habe Zeiger, die immer auf ein
gültigen Objekt zeigen müssen, dann stellt man das durch entsprechendes
Design sicher und brauch auch nichts zu prüfen.
mfg Torsten
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Daniel Albuschat
Guest
|
| Posted: Mon May 10, 2004 5:56 pm Post subject: Re: Dereferenzieren von NULL / Standard-Exceptions |
|
|
F. Bugauer wrote:
[snip]
Dazu, dass das Dereferenzieren eines Nullpointers keine
Exception wirft, haben ja meine Vorposter schon was gesagt.
| Quote: | // irgendwo im Code
MyClass * m; // oder auch: MyClass * m = NULL;
|
Hier ist allerdings ein weiterer Denkfehler:
Dem Kommentar entnehme ich, dass du die Statements
und
| Quote: | MyClass *m = NULL;
|
fuer aequivalent haeltst.
Dies ist allerdings nicht der Fall.
Pointer und eingebaute Typen werden in C++ nicht durch
einen Konstruktor initialisiert. Stattdessen steht in derem
Speicherraum das, was zuvor hineingeschrieben wurde. Und das
kann beliebig sein.
D.h. soetwas koennte u.U. 1000 Mal funktionieren, aber beim
tausendundersten Mal abstuerzen:
| Quote: | MyClass *m;
/* ... */
if( m != 0 )
m->methode();
|
Noch eine Anmerkung zum Stil: In C++ wird eher die Konstante 0
als das Makro NULL verwendet. Darueber scheiden
sich zwar die Geister, aber soweit ich das sehe wird 0 in dieser
Gruppe auch eindeutig bevorzugt.
Grund dafuer ist, dass NULL evtl. als etwas anderes als 0 definiert
sein koennte, und fuer 0 im Pointer-Kontext in C++ besondere Regeln
gelten.
MfG,
Daniel Albuschat
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
Martin Kaul
Guest
|
| Posted: Wed May 12, 2004 9:34 am Post subject: Re: Dereferenzieren von NULL / Standard-Exceptions |
|
|
F. Bugauer wrote:
| Quote: | Hallo
Ich arbeite erst seit Kurzem unter C++ mit Exceptions und versuche nun
schon einige Stunden, einen Codeabschnitt zum Laufen zu bringen.
Offensichtlich habe ich mir aber etwas falsch überlegt: Ich habe
meinen Denkfehler auf folgendes kleines Beispiel eingeschränkt:
// irgendwo im Code
MyClass * m; // oder auch: MyClass * m = NULL;
try {
m->printList();
}
catch (std::exception & e){
cout << "Exception: " << e.what();
}
Meiner Ansicht nach müsste m-> eine Standardexception auslösen, da
versucht wird, NULL zu dereferenzieren. Leider komme ich aber nicht in
den catch-Teil hinein, das ganze bricht direkt ab.
Ich kann mir kaum vorstellen, dass ich unter c++ jedes Dereferenzieren
manuell überprüfen muss um ggf. eine Exception zu werfen. Leider habe
ich nur sehr wenig zu den Standardexceptions im Netz gefunden und bin
daher auf Eure Hilfe angewiesen.
|
Wenn du von C++ dieses Verhalten willst, dann musst du es
implementieren...
In diesem Fall ist der Zeiger dann kein "normaler" Zeiger, sondern
eine Adapterklasse, welche die gewünschte Aufgabe (in deinem Fall
das Werfen der Ausnahme) übernimmt.
einfaches Beispiel:
--------------------
template< typename T >
class save_pointer
{
T *pointer_;
public:
save_pointer( T *pointer=0 )
: pointer_ ( pointer )
{
}
~save_pointer()
{
}
save_pointer( const save_pointer © )
: pointer_ ( copy.pointer_ )
{
}
const save_pointer &operator=( const save_pointer © )
{
pointer_ = copy.pointer_;
return *this;
}
T *operator*()
{
if( !pointer_ )
throw std::runtime_error( "pointer not initialized" );
return pointer_;
}
T *operator->()
{
if( !pointer_ )
throw std::runtime_error( "pointer not initialized" );
return pointer_;
}
operator T *()
{
if( !pointer_ )
throw std::runtime_error( "pointer not initialized" );
return pointer_;
}
};
--------------------
Anwendung:
--------------------
save_pointer< MyClass > m;
m->printList(); // --> wirft Ausnahme
m = new MyClass;
m->printList(); // --> wirft *keine* Ausnahme
delete m;
--------------------
tschaule
Martin
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
|
FAQ
Search
Memberlist
Usergroups
Register
Profile
Log in to check your private messages
Log in
