 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Martin Heibel
Guest
|
 Posted: Tue Sep 02, 2003 5:52 pm Post subject: Re: Stilfrage: *& oder ** |
 |
|
Jan Boehme schrieb:
| Quote: | Hallo!
Bei Funktionsparametern stellt sich des öfteren die Frage, welche der
beiden Varianten nun einzusetzen ist. Ich preferiere die Variante *&
Die stellt sich eigentlich nicht (dazu gab es vor Kurzem einen Thread). |
| Quote: | bool testFunc(Class* &_pObj)
{
// Zeiger umhängen
_pObj = ...;
}
Ok. |
| Quote: |
Class* m_pObj=0;
if(testFunc(m_pObj))
m_pObj->jetztKannIch();
gegenüber dieser
testFunc(Class** _ppObj)
{
// Zeiger umhängen
*_ppObj = ...;
}
Nur dann ok, wenn _ppObj optional ist, sprich 0 sein kann. |
| Quote: |
Class* m_pObj=0;
if(testFunc(&m_pObj))
m_pObj->jetztKannIch();
da sie meiner Meinung nach besser nachzuvollziehen ist.
Gibt es noch eine Möglichkeit, sowas zu machen und welche verwendet ihr?
Gar keine. Ich habe seit Jahren keine solchen Konstrukte mehr benutzt, weil |
ich Pointer für genau zwei Zwecke benutze:
1. Optionale Funktionsparameter (extrem selten)
2. Für Beziehungen im weitesten Sinn. Dabei ist der Pointer ein Member in
einem Objekt, das die Kontrolle über ihn hat.
In beiden Fällen benötigt man keinen Pointer als 'out'-Parameter. Nach
meiner Erfahrung ist das eine der fragestellungen, die aus einem
Designfehler resultieren.
Wenn Du das Konstrukt benötigst, weil Dich existierender Code dazu zwingt,
dann empfehle ich eine der folgenden Varianten:
*auf die harte Tour*
Class* testFunc() throw(SomeException)
{ ... }
oder, wenn der aktuelle Zustand des Pointers relevant für die Funktion ist:
Class* testFunc(Class* p) throw(SomeException)
{ ... }
*Fehlertolerant*
(Nur wenn ein Verschleppen des Fehlers unkritisch ist)
class TestFunctor
{
public:
Class* operator() throw(); // evtl. mit Parameter
bool ok() const;
};
Gruß,
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 |
|
 |
Markus Breuer
Guest
|
| Posted: Tue Sep 02, 2003 8:24 pm Post subject: Re: Stilfrage: *& oder ** |
|
|
Jan Boehme schrieb:
| Quote: | Hallo!
Bei Funktionsparametern stellt sich des öfteren die Frage, welche der
beiden Varianten nun einzusetzen ist. Ich preferiere die Variante *&
bool testFunc(Class* &_pObj)
{
// Zeiger umhängen
_pObj = ...;
}
|
Das kann aber auch gewaltig nach hinten losgehen. Wenn wir einmal davon
ausgehen, dass ein unbedarfter diese Funktion verwendet, dann kann
folgendes ein fataler Fehler sein:
Class *instance = new Class;
testFunc( instance );
Grundsätzlich ist das kein Fehler. Aber was passiert, wenn _pObj
gespeichert oder (OT) in einem Thread weiter verarbeitet wird? Jeder
Zugriff nachdem instance, ein lokale Variable, zerstört wurde, greift
auf ungültige Daten zu. Man sollte sich daher bewusst machen, was man
bei einer solchen Funktion NICHT machen darf.
Ich erwähne das, weil ich vor kurzem eine Diskussion über die Verwendung
von *& hatte. Wie gesagt, solange man sich dessen bewusst ist, ist die
Verwendung kein Problem. Aber bitte darauf achten, dass es nicht falsch
verwendet wird oder ein Anfänger auf falsche Gedanken kommt!
Gruß Markus
--
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 |
|
|
Christian Wimmer
Guest
|
| Posted: Sun Sep 14, 2003 10:32 am Post subject: Re: Stilfrage: *& oder ** |
|
|
Am Tue, 02 Sep 2003 16:04:32 +0200 hat Jan Boehme <jb (AT) ype (DOT) de> geschrieben:
Bei Funktionsparametern stellt sich des öfteren die Frage, welche der
beiden Varianten nun einzusetzen ist. Ich preferiere die Variante *&
bool testFunc(Class* &_pObj)
{
// Zeiger umhängen
_pObj = ...;
}
Class* m_pObj=0;
if(testFunc(m_pObj))
m_pObj->jetztKannIch();
gegenüber dieser
testFunc(Class** _ppObj)
{
// Zeiger umhängen
*_ppObj = ...;
}
Class* m_pObj=0;
if(testFunc(&m_pObj))
m_pObj->jetztKannIch();
da sie meiner Meinung nach besser nachzuvollziehen ist.
Gibt es noch eine Möglichkeit, sowas zu machen und welche verwendet ihr?
Grüße, Jan.
** wird in C verwendet, weil der Referenzoperator & nicht existiert.
aber sonst ist es relativ egal - außer du programmierst in C.
da ich aber nur C++ programmiere verwende ich auch eher *&.
--
chris4y(at)gmx.de
--
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 |
|
|
Werner Salomon
Guest
|
| Posted: Mon Sep 15, 2003 12:57 pm Post subject: Re: Stilfrage: *& oder ** |
|
|
Jan Boehme <jb (AT) ype (DOT) de> wrote
| Quote: | Hallo!
Bei Funktionsparametern stellt sich des öfteren die Frage, welche der
beiden Varianten nun einzusetzen ist. Ich preferiere die Variante *&
bool testFunc(Class* &_pObj)
{
// Zeiger umhängen
_pObj = ...;
}
Class* m_pObj=0;
if(testFunc(m_pObj))
m_pObj->jetztKannIch();
gegenüber dieser
testFunc(Class** _ppObj)
{
// Zeiger umhängen
*_ppObj = ...;
}
Class* m_pObj=0;
if(testFunc(&m_pObj))
m_pObj->jetztKannIch();
da sie meiner Meinung nach besser nachzuvollziehen ist.
Gibt es noch eine Möglichkeit, sowas zu machen und welche verwendet ihr?
|
Hallo Jan,
ich versuche grundsätzlich, das Ergebnis einer Funktion (oder Methode)
als Returncode zurück zu geben und eine evt. notwendige
Fehlerbehandlung über Exceptions zu machen.
Statt:
Class* m_pObj=0;
if(testFunc(&m_pObj)) // oder if(testFunc(m_pObj))
m_pObj->jetztKannIch();
geht dann einfacher
testFunc()->jetztKannIch();
bzw. i.A. muss der Pointer gemerkt - weil gelöscht - werden:
Class* m_pObj=testFunc();
m_pObj->jetztKannIch();
bzw. ich benutze auch Pointer selten, daher noch besser:
Smart_Ptr< Class > m_pObj( testFunc() );
m_pObj->jetztKannIch();
und wenn jetzt das 'testFunc()' selbst auch den Smart_Ptr liefert,
Smart_Ptr< Class > testFunc();
so kann ich tatsächlich ohne Memory-Leak schreiben:
testFunc()->jetztKannIch(); // s.o.
und selbst wenn m_pObj bereits belegt ist, oder auch nicht, ist
folgendes eine sichere Sache:
Smart_Ptr< Class > m_pObj;
m_pObj = .. // ??
// später
m_pObj = testFunc(); // ist sicher !
... egal ob der Smart-Pointer vorher bereits auf ein Objekt zeigt oder
nicht.
Wenn's dann doch mal sein muss, Pointer als variablen Parameter zu
übergeben, dann bevorzuge ich:
typedef Class* ClassPtr;
bool testFunc( ClassPtr& _pObj ) {
// Zeiger umhängen
_pObj = ...;
}
... das ist für mich einfach C++-Stil. Warum das 'besser' ist, haben
die anderen ja schon gesagt.
Gruß
Werner
--
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
