warum funktioniert der Code trotz der auskommentierten Zeile? Müsste der Pointer nicht NULL sein?

Ausgabe: Hey

ButtonClick:

virtual void OnButton1Click(wxCommandEvent& event)
{
	Body aaa;

	aaa.SetSuper("Toll");

	//aaa.SetCool(new Fuss());

	aaa.GetCool()->SetHolla("Hey");

	StaticText1->SetLabel(aaa.GetCool()->GetHolla());
}

Body.h

#ifndef __Body__
#define __Body__

#include <Fuss.h>

class Body
{
	private:
		wxString _Super;
		Fuss* _Cool;

	public:
		wxString GetSuper()
		{
			return _Super;
		}

		void SetSuper(wxString parSuper)
		{
			_Super = parSuper;
		}

	public:
		Fuss* GetCool()
		{
			return _Cool;
		}

		void SetCool(Fuss* parCool)
		{
			_Cool = parCool;
		}
};

#endif // __Body__

Fuss.h

#ifndef __Fuss__
#define __Fuss__

class Fuss
{
	private:
		wxString _Holla;

	public:
		wxString GetHolla()
		{
			return _Holla;
		}

		void SetHolla(wxString parHolla)
		{
			_Holla = parHolla;
		}

};

#endif // __Fuss__

Mit freundlichen Grüßen,
DarkBug

Der Pointer ist nur dann 0(NULL) wenn du ihn auch mit 0 initialisierst.

public:
	Body()
	{
		_Cool = NULL;
	}

Ist es möglich anstelle des Pointers _Cool ein normales Objekt der Klasse Fuss zu verwenden? Wenn ja, wie?

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Übrigens: Dein Code verwendet Bezeichner, die für die Implementierung (also den Compiler und die Standardbibliothek) reserviert sind. Alles, was __ enthält oder mit _ und einem Großbuchstaben beginnt, darfst du nicht benutzen, und im globalen Scope außerdem alles andere nicht, was mit einem Unterstrich beginnt. Das heißt

#ifndef __Body__ // <-- FEHLER!
#define __Body__

#include <Fuss.h>

class Body
{
    private:
        wxString _Super; // <-- FEHLER!
        Fuss* _Cool;     // <-- Gleicher Fehler!

...

von den oben beschriebenen Regeln abgesehen bist du in deiner Bezeichnerwahl allerdings frei, also gibt es viele Wege, das aufzulösen. Ich hätte

#ifndef INCLUDED_MYLIB_BODY_H
#define INCLUDED_MYLIB_BODY_H

#include "Fuss.h" // lokaler Header

class Body
{
  private:
    wxString super_;
    Fuss     cool_;

...

geschrieben, wobei MYLIB ein eindeutiger Bezeichner für das betreffende Projekt wäre. Andere Leute haben andere Vorlieben.

ButtonClick:

virtual void OnButton1Click(wxCommandEvent& event)
{
	Body aaa;

	aaa.SetSuper("Toll");

	aaa.GetCool().SetHolla("Hey");

	StaticText1->SetLabel(aaa.GetCool().GetHolla());
}

Body.h

#ifndef __Body__
#define __Body__

#include <Fuss.h>

class Body
{
	private:
		wxString _Super;
		Fuss _Cool;

	public:
		wxString GetSuper()
		{
			return _Super;
		}

	public:
		void SetSuper(wxString parSuper)
		{
			_Super = parSuper;
		}

	public:
		Fuss GetCool()
		{
			return _Cool;
		}

	public:
		void SetCool(Fuss parCool)
		{
			_Cool = parCool;
		}
};

#endif // __Body__

Fuss.h

#ifndef __Fuss__
#define __Fuss__

class Fuss
{
	private:
		wxString _Holla;

	public:
		wxString GetHolla()
		{
			return _Holla;
		}

	public:
		void SetHolla(wxString parHolla)
		{
			_Holla = parHolla;
		}
};

#endif // __Fuss__

Den Include Guard habe ich dem wxFormBuilder entnommen, dieser macht dies genauso.

Foo.h

#ifndef __Foo__
#define __Foo__

class Foo
{
	private:
		wxString Test;

	public:
		void SetTest(wxString& inTest)
		{
			Test = inTest;
		}

	public:
		wxString& GetTest()
		{
			return Test;
		}
};

#endif

EventHandler:

virtual void OnButton1Click(wxCommandEvent& event)
		{
			Foo Blau;
			Blau.SetTest("WessenBlau");

			Button1->SetLabel(Blau.GetTest());
		}

Der Compiler scheint das & bei SetTest nicht zu mögen. Warum?
Fehler: keine passende Funktion für Aufruf von »Foo::SetTest(const char [13])«

Sehe ich es richtig, das man immer Referenzen benutzen sollte und nie Kopien bei Methodenaufrufen?

Nein, siehst du nicht richtig. Man sollte den Unterschied kennen und immer wissen, was man braucht. Außerdem solltest du dich mit der Bedeutung von const vertraut machen - davon fehlen ein oder mehrere in deinem Code.

Foo.h

#ifndef __Foo__
#define __Foo__

Schau nochmal, was seldon oben geschrieben hat. __Foo__ ist ein reservierter Bezeichner.

Sehe ich es richtig, das man immer Referenzen benutzen sollte und nie Kopien bei Methodenaufrufen?

Ja, jedoch nur unter der Bedingung, dass eine Kopie teurer ist, als eine Referenzübergabe. Bei fundamentalen Typen und bei Typen, deren Größen im Bereich eines fundamentalen Typs liegen, nimmst du call-by-value, da eine Kopie hier billiger ist. Sprich sizeof(object)<=12 call-by-value, ansonsten call-by-ref.

DarkBug schrieb:

Der Compiler scheint das & bei SetTest nicht zu mögen. Warum?
Fehler: keine passende Funktion für Aufruf von »Foo::SetTest(const char [13])«

Blau.SetTest("WessenBlau"); erzeugt ein temporäres Objekt. Temporäre Objekte darfst du nur an eine const-ref binden. SetTest(const wxString& inTest) Abgesehen davon, man verwendet eigentlich immer const-ref. Das, das du momentan hast, wird in einem anderen Kontext verwendet, nämlich für out-Parameter. out-Parameter ermöglichen dir eine beliebige Anzahl return-Werte. In deinem Fall willst du aber keinen return-Wert, darum const-ref.

Und noch was, doppelte Unterstriche sind glaube ich nicht erlaubt. __Foo__

const & für primitive Datentypen wie wxString, wxInt32, wxDouble etc.
keinen zusatz für normale Klassen wie wxButton, wxFrame, wxSocketBase etc.
Wenn ja warum nicht auch const &?

& wenn die Methode das Objekt an der Aufrufstelle verändern soll
* wenn die Methode das Objekt an der Aufrufstelle verändern soll
und/oder wenn auf NULL geprüft werden muss
sowie eventuell das Objekt gewechselt werden soll

Stimmt das so?

Referenzen muss man nicht wie Pointer mit delete irgendwie löschen, oder?

Stimmt das so?

Es ist egal welche Typen im Spiel sind, das kann man so nicht verallgemeinern. Wenn Du einen wxButton "ohne Zusatz" übergibst, wird das Objekt kopiert, was entweder schiefgeht (wenn wxWidgets so vernünftig programmiert ist, dass sich Widgets nicht kopieren lassen) oder garantiert nicht das macht, was Du möchtest. const-reference Übergabe macht überall dort Sinn, wo ein Objekt nicht verändert werden soll, aber nicht kopiert werden kann oder die Kopie zu aufwändig ist. Und was ist mit einem "primitiven Datentypen", der an der aufgerufenen Stelle verändert werden soll?

EDIT:
Ich versuche mal, ein paar mögliche Szenarien sinnvoll zu umreissen.

kein Qualifizierer   Ursprungsobjekt soll nicht verändert werden UND ( Kopie ist
                     erwünscht ODER die Kopie unaufwändig, z.B. für int, char, 
                     short, ... )
const &              Objekt soll nicht verändert werden UND ( Objekt ist nicht
                     kopierbar ODER die Kopie unerwünsch oder aufwändig, z.B.
                     wxString, wxButton, ... )
&                    Objekt soll verändert werden (Hier ein Hinweis: Man kann
                     auch Objekte, zu denen nur ein Zeiger existiert per 
                     Referenz übergeben, indem man sie dereferenziert. Man kann
                     auch Zeiger per Referenz übergeben, wenn man & und * kom-
                     biniert
*                    Spezialfälle  :p

Referenzen muss man nicht wie Pointer mit delete irgendwie löschen, oder?

Du musst weder Referenzen noch Pointer mit delete löschen, sondern per new erstellte Objekte. Dass deren Adressen häufig in Pointern gespeichert werden, ist eine andere Sache. Aber auch hier hängt's vom Anwendungsfall ab. Wenn Du z.B. einen Pointer auf ein Objekt bekommst, welches Dir nicht gehört, solltest Du das mit dem Löschen tunlist bleiben lassen.

Wenn dem so ist, würdest du in meinem Beispiel keine Referenzen und auch keine Pointer verwenden, korrekt?

Foo.h

#ifndef Foo_
#define Foo_

class Foo
{
    private:
        wxString Test;

    public:
        void SetTest(wxString inTest)
        {
            Test = inTest;
        }

    public:
        wxString GetTest()
        {
            return Test;
        }
};

#endif // Foo_

EventHandler:

virtual void OnButton1Click(wxCommandEvent& event)
{
    Foo Blau;
    Blau.SetTest("WessenBlau");

    Button1->SetLabel(Blau.GetTest());
}

Foo.h

#ifndef Foo_ 
#define Foo_ 

class Foo 
{ 
    private: 
        wxString Test; 

    public: 
        void SetTest(const wxString& inTest) 
        { 
            Test = inTest;
        } 

    public: 
        wxString GetTest() 
        { 
            return Test; 
        } 
}; 

#endif // Foo_

In Zeile 12 wird der Wert der Referenz in die Variable Test gespeichert, oder wird nur die Referenz irgendwie kopiert?

Wie benutze ich const bei GetTest? const wxString& macht hier ja keinen Sinn, da der Rückgabestring ja eh nicht verändert werden kann, die Membervariable aber schon. Wie verhindere ich das?

In Zeile 12 wird der Wert der Referenz in die Variable Test gespeichert, oder wird nur die Referenz irgendwie kopiert?

Ersteres.

Wie benutze ich const bei GetTest? const wxString& macht hier ja keinen Sinn,

Doch!

da der Rückgabestring ja eh nicht verändert werden kann,

Häh? Warum nicht?

die Membervariable aber schon. Wie verhindere ich das?

Siehe oben. Außerdem sollte die ganze Methode gleich mit const sein. Also:

const wxString& GetTest() const
{
 return Test;
}

(Disclaimer: Alles unter der Voraussetzung, dass wxstring eine halbwegs "normale" Semantik hat. Bei diesen GUI-Frameworks weiß man ja nie…)

Also würde ein

wxString& GetTest() const
{
 return Test;
}

doch reichen, oder?

Das const rechts von einer Methode verhindert, das man in dieser Methode keine Membervariablen verändern kann, oder?

Foo.h

#ifndef __Foo__
#define __Foo__

class Foo
{
	private:
		wxString Test;

	public:
		void SetTest(const wxString& inTest)
		{
			Test = inTest;
		}

	public:
		const wxString& GetTest() const
		{
			return Test;
		}
};

#endif

App.cpp

#ifdef WX_PRECOMP
#include "wx_pch.h"
#endif

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#include <wx/wx.h>

#include "MainFrame.h"

class App : public wxApp
{
    public: virtual bool OnInit()
    {
        MainFrame* mfMainFrame = new MainFrame(0L);
        mfMainFrame->SetIcon(wxICON(MainIcon));
        mfMainFrame->Show();

        return true;
    }
};

IMPLEMENT_APP(App);

MainFrame.h

///////////////////////////////////////////////////////////////////////////
// C++ code generated with wxFormBuilder (version Sep  8 2010)
// http://www.wxformbuilder.org/
//
// PLEASE DO "NOT" EDIT THIS FILE!
///////////////////////////////////////////////////////////////////////////

#ifndef __MainFrame__
#define __MainFrame__

#include <wx/string.h>
#include <wx/button.h>
#include <wx/gdicmn.h>
#include <wx/font.h>
#include <wx/colour.h>
#include <wx/settings.h>
#include <wx/sizer.h>
#include <wx/frame.h>

#include "Foo.h"

///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
/// Class MainFrame
///////////////////////////////////////////////////////////////////////////////
class MainFrame : public wxFrame
{
	private:

	protected:
		wxButton* Button1;

		virtual void OnButton1Click(wxCommandEvent& event)
		{
			Foo Blau;
			wxString Eins = "Eins";
			wxString Zwei = "";

			Blau.SetTest(Eins);
			Zwei = Blau.GetTest();

			Button1->SetLabel(Zwei);
		}

	public:

		MainFrame(wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize(500,300), long style = wxDEFAULT_FRAME_STYLE|wxTAB_TRAVERSAL);
		~MainFrame();

};

#endif //__MainFrame__

MainFrame.cpp

///////////////////////////////////////////////////////////////////////////
// C++ code generated with wxFormBuilder (version Sep  8 2010)
// http://www.wxformbuilder.org/
//
// PLEASE DO "NOT" EDIT THIS FILE!
///////////////////////////////////////////////////////////////////////////

#include "MainFrame.h"

///////////////////////////////////////////////////////////////////////////

MainFrame::MainFrame( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style )
{
	this->SetSizeHints( wxDefaultSize, wxDefaultSize );

	wxBoxSizer* BoxSizer1;
	BoxSizer1 = new wxBoxSizer( wxVERTICAL );

	Button1 = new wxButton( this, wxID_ANY, wxT("MyButton"), wxDefaultPosition, wxDefaultSize, 0 );
	BoxSizer1->Add( Button1, 0, wxALL, 5 );

	this->SetSizer( BoxSizer1 );
	this->Layout();

	this->Centre( wxBOTH );

	// Connect Events
	Button1->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MainFrame::OnButton1Click ), NULL, this );
}

MainFrame::~MainFrame()
{
	// Disconnect Events
	Button1->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MainFrame::OnButton1Click ), NULL, this );

}