Zeiger als Parameter - aber wie?

Ich habe folgenden Code:

#include <iostream>
using namespace std;

struct Test
{
 virtual int GetValue() { return iValue; }
 virtual void SetValue(int Value) { iValue = Value; }
 int iValue;
}

void foo(Test* ptr) 
{
  cout << ptr->GetValue() << endl; // <-hier knallts dann (im ptr steht Müll)
 return;
}

int main()
{
  Test* local_ptr = new Test();
  local_ptr->SetValue(777);
  foo(local_ptr); // <-- erzeugt einen uninitalisierten ptr, warum?
  return 0;
}

Ich zermarter mir das Gehirn, und iregend etwas mit "Da muss ein Pointer auf Pointer als Parameter hin" schwirrt durch mein Gehirn aber ich komme nich drauf warum!

Grüsse Uwe

unskilled

sieht eigtl korrekt aus - welchen compiler nutzt du? hast du wirklich 1:1 das hier compilieren lassen?

bb

l'abra d'or

Ganz 1:1 kann das nicht sein

g++ main.cpp -o main
main.cpp:4: Fehler: new types may not be defined in a return type
main.cpp:4: Anmerkung: (vielleicht fehlt ein Semikolon hinter der Definition von »Test«)
[ ... ]

Ansonsten kannst du ja mal testweise die Klammern hinter dem Konstruktoraufruf wegmachen:

Test* local_ptr = new Test;

Wobei es das nicht sein sollte...

Entweder obermistiger Compiler oder Fehler beim Abtippen.

freakC++

Hinter die struct Deklaration kommt ein Semikolon.

lg, freakC++

Ok, ok, steinigt mich... ich habe tatsächlich ein Komma vergessen, aber das war ja auch nur zum Beispiel (und vor allem ungetestet) gewesen da der eigentliche Source um längen komplizierter ist, ich wollte es halt auf das wesentliche reduzieren und kein lauffähiges Demo des Fehlers produzieren.

Ok, hier jetzt mal was komplizierters und was näher am Problem liegt (nicht getestet):

struct IApplication
{
 //viele pure virtual Funktionen
}; //<-- und jetzt auch mit Komma ;)

class AppInterface : public IApplication
{
  //implementierung der pure virtual Funktionen
};

struct ITool
{
  //viele pure virtual Funktionen
};

class Tool
{
private:
  IApplication* mp_Application;
public:
  Tool(IApplication* Application) 
   :mp_Application(Application)  // <-- hier kommt dann nur Müll an, ungültiger Zeiger

  //implementierung der pure virtual Funktionen
};

class Plugin
{
private:
  IApplication* mp_Application;
  ITool* mp_Tool;
public:
  Plugin(IApplication* Application) 
     :mp_Application( Application )
     {
        mp_Tool = new Tool(mp_Application); 
     }
};

int main()
{
   AppInterface Application;
   Plugin* plug = new Plugin(&Application);

   return 0;
}

Der Compiler ist (VS2009-32Bit) Ver 15.00.xxxx 80x86, Grüße Uwe.

Müsli essen, ich sag nur Müsli essen!

Ich habe den Fehler gefunden, es ist zum Haare raufen, der Fehler lag hier:

// Klasse stellt grundlegende Funktionsimplementierung von ITool zur Verfügung
class ToolAdapter : public ITool
{
protected:
  IApplication* mp_Application;
public: 
  ToolAdapter(IApplication* Application) 
    :mp_Application(Application) {}
  // Funktionen 
};

class Tool : public ToolAdapter
{
public:
    Tool(IApplication* Application) :
    ToolAdapter(mp_Application) {}  //<-- Und das haut natürlich niemals hin!
                                    // der eigentliche Konstruktor ist natürlich 
                                    // bei weitem umfangreicher als dieses Beispiel
};

Mann ich sage euch, manchmal da....

Grüße von Uwe!

unskilled

gz