 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Immanuel Albrecht
Guest
|
 Posted: Mon Sep 08, 2003 9:30 pm Post subject: Re: Wie gebe ich was bei operator+ zurück? |
 |
|
Christoph Jerolimov <jerolimov (AT) gmx (DOT) de> wrote in news:3f5cd702$1
@news.ginko.net:
| Quote: | Mein Problem ist die Methode *cxInt& cxInt::operator+ (int value)*, hier
erstelle ich ja eine neue Instanz vom Typ cxInt und diese ist ja
eigendlich nach dem Beenden der jeweiligen Methode wieder ungültig,
genau das sagt mir auch meine IDE (Dev-C++): [WARNING] reference to
local variable 'result' returned.
Wie macht man das sonst, kann mir das vielleicht wer verraten. 
|
Keine reference zurückgeben. Also
cxInt operator+ (int rval);
mfg
--
http://xrxixpx.rip-productions.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 |
|
 |
Jan Langer
Guest
|
| Posted: Mon Sep 08, 2003 9:38 pm Post subject: Re: Wie gebe ich was bei operator+ zurück? |
|
|
Christoph Jerolimov wrote:
| Quote: | class cxInt {
private:
int m_value;
public:
cxInt ();
cxInt (const int value);
cxInt (const char *value);
cxInt (const char *value, const int length);
cxInt (const cxInt &value);
cxInt& operator+ (int value);
int getIntValue();
};
....
Mein Problem ist die Methode *cxInt& cxInt::operator+ (int value)*, hier
erstelle ich ja eine neue Instanz vom Typ cxInt und diese ist ja
eigendlich nach dem Beenden der jeweiligen Methode wieder ungültig,
genau das sagt mir auch meine IDE (Dev-C++): [WARNING] reference to
local variable 'result' returned.
Wie macht man das sonst, kann mir das vielleicht wer verraten.
|
nabend,
indem du ganz einfach keine referenz zurueckgibst. also einfach
cxInt operator + (int value);
noch besser waere es bestimmt, wenn du den operator ausserhalb der
klasse deklarierst und seine argumente zu cxInt wandelst.
cxInt operator + (cxInt lhs, cxInt rhs);
da funktioniert dann auch
cxInt a = 0;
cxInt b = 17 + a;
cxInt c = a + 3;
cxInt d = b + c;
jan
--
jan langer ... [email]jan (AT) langernetz (DOT) de[/email]
"pi ist genau drei"
--
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 09, 2003 5:56 am Post subject: Re: Wie gebe ich was bei operator+ zurück? |
|
|
| Quote: | nabend,
indem du ganz einfach keine referenz zurueckgibst. also einfach
cxInt operator + (int value);
|
Da dein Operator praktisch nichts an deiner Klasse ändert, sondern nur
einen temporären Zwischenwert zurück gibt, kannst du die Methode auch
als const deklarieren:
cxInt operator + (int value) const;
Damit verhält sich der operator konform zu anderen +-operatoren.
Greuß 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 |
|
|
Christoph Rabel
Guest
|
| Posted: Tue Sep 09, 2003 9:21 am Post subject: Re: Wie gebe ich was bei operator+ zurück? |
|
|
Christoph Jerolimov wrote:
| Quote: | Jan Langer wrote:
indem du ganz einfach keine referenz zurueckgibst. also einfach
cxInt operator + (int value);
So eine Funktion habe ich ja auch, ich würde aber gerne auch zusätzlich
das Objekte vom Typ cxInt addieren:
|
Der beste Weg das zu lösen ist so:
cxInt operator+ (cxInt const& left, cxInt const& right)
{
cxInt tmp(left);
return tmp += right;
}
Beachte das dieser Operator kein member der Klasse ist.
| Quote: | Kann es sein das evtl. sogar so schon klappt, immerhin kommt ja zur
laufzeit kein Speicher-Fehler oder sonst was.
Vielleicht wird die Instanze erst nach dem abarbeiten des kompletten
Befehls automatisch gelöscht? Oder gar nicht??
|
Könntest du die Frage umformulieren, worauf willst du hinaus?
Falls du meinst, das es trotz der Referenz als Rückgabewert klappt, so
muss ich dich enttäuschen. Du es funktioniert ist nur "Zufall".
mfg
Christoph
--
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 |
|
|
Christoph Rabel
Guest
|
| Posted: Tue Sep 09, 2003 9:38 am Post subject: Re: Wie gebe ich was bei operator+ zurück? |
|
|
Christoph Jerolimov wrote:
| Quote: | --------------------- TEST VON CXINT ---------------------
--------------------------- CXINT.H ---------------------------
#ifndef CX_INT
#define CX_INT
class cxInt {
private:
int m_value;
public:
cxInt ();
cxInt (const int value);
|
Das const ist hier nicht nötig, du kannst es weglassen. Ausserdem kannst
du die beiden Konstruktoren zu einem zusammenfassen:
cxInt (int value = 0);
| Quote: | cxInt (const char *value);
cxInt (const char *value, const int length);
|
Hier auch (das hintere ist gemeint)
| Quote: | cxInt (const cxInt &value);
cxInt& operator+ (int value);
|
Wurde ja schon kommentiert.
Ich würde diesen Operator komplett weglassen und stattdessen einen Operator:
cxInt& operator+ (cxInt const& value)
{
m_value += value.m_value;
return *this;
}
schreiben.
Und ausserhalb der Klasse den im anderen Posting angesprochenen
operator+. int kann automatisch in cxInt konvertiert werden, daher
sollten diese beiden genügen.
| Quote: | int getIntValue();
int getIntValue() const; |
| Quote: | ---------------------------- CXINT.CPP -------------------------
#include <iostream
#include
|
#include
| Quote: | #include "cxint.h"
cxInt::cxInt() {
m_value = 0;
}
cxInt::cxInt(const int value) {
m_value = value;
}
|
Besser mit der Initialisierungsliste arbeiten:
cxInt::cxInt(const int value) : m_value(value)
{ }
Hat diverse Vorteile, ist effizienter(nur bei eigenen Typen) und du
kannst auch Konstanten initialisieren.
| Quote: | cxInt::cxInt (const char *value) {
|
Ich würde hier zumindest ein
assert(value);
einbauen damit ich keinen Nullpointer übergeben bekommen (k.A. ob atoi
damit umgehen kann, ist mir auch egal)
Noch besser wäre:
if (!value)
m_value = 0;
else
| Quote: | m_value = atoi(value);
}
|
Eventuell würde ich sogar beides machen oder eine Exception werfen.
Die beste Lösung ist meiner Meinung nach den ganzen Konstruktor
wegzulassen. Soll doch der Aufrufer den char* konvertieren.
| Quote: | cxInt::cxInt (const char *value, const int length) {
m_value = 0;
}
cxInt::cxInt (const cxInt &value) {
}
|
Ich nehme an, diese beiden hast du einfach noch nicht implementiert.
mfg
Christoph
--
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 09, 2003 11:08 am Post subject: Re: Wie gebe ich was bei operator+ zurück? |
|
|
| Quote: | // externe Operatoren
cxint
operator+ (const cxint& lhs, const cxint& rhs) {
cxint result;
// Implementation
return result;
}
|
Welchen Vorteil hat es eigentlich, diesen Operator als extern du
deklarieren? Konkret auf den obigen Fall bezogen sehe ich keinen
Unterschied zu einem Operator innerhalb der Klasse. Auch dann nicht,
wenn die Operanden vertauscht werden.
Spricht etwas dagegen, ihn intern zu halten?
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 |
|
|
Kostka, Volkmar
Guest
|
| Posted: Tue Sep 09, 2003 11:16 am Post subject: Re: Wie gebe ich was bei operator+ zurück? |
|
|
Hallo,
Markus Breuer wrote:
| Quote: | // externe Operatoren
cxint
operator+ (const cxint& lhs, const cxint& rhs) {
cxint result;
// Implementation
return result;
}
Welchen Vorteil hat es eigentlich, diesen Operator als extern du
deklarieren? Konkret auf den obigen Fall bezogen sehe ich keinen
Unterschied zu einem Operator innerhalb der Klasse. Auch dann nicht,
wenn die Operanden vertauscht werden.
Spricht etwas dagegen, ihn intern zu halten?
|
Ja.
cxint ci = 5 + cxint(4);
Der Compiler sucht hier nach einem Operator, der einen int und einen
cxint addieren kann. Intern kannst du nur einen definieren, der einen
int zu einem cxint addiren kann, aber nicht umgekehrt,
bei einem internen Operator ist immer der Typ des linken Operanden durch
die Klasse festgelegt. Nur der rechte Typ kann frei gewaehlt werden.
Bei einem externen koennen beide Typen frei (zumindestens fast) gewaehlt
werden, da dann auch implizite Konvertierungen geprueft werden.
HTH
MFG
Volkmar Kostka
--
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
