Welche Form bist du?

audacia

Oder du deklarierst ein Interface, das beide implementieren.

witte

vulcano schrieb:

hallo jungs. ich muss euch leider nochmals belasten
das hilft mir leider nicht wirklich weiter. polymorphie aus dem grund nicht, weil ich nicht auf methoden zugreiffen muss, sondern auf objekte.

Dann bau' Dir doch eine Methode, die einen Zeiger oder eine Referenz auf diese Imageobjekte zurückgibt.

vlad_tepesch

Dann bau' Dir doch eine Methode, die einen Zeiger oder eine Referenz auf diese Imageobjekte zurückgibt.

Das setzt trotzdem eine gemiensame Basisklasse oder Interface voraus

witte

vlad_tepesch schrieb:

Das setzt trotzdem eine gemiensame Basisklasse oder Interface voraus

Ach nee, was meinst Du was wir ihm die ganze Zeit empfehlen . Er wusste nur nicht wie er an Member herankommen soll.

hm, könnt ihr mir bitte ein beispiel machen? weil irgendwie ist das mit VCL komponenten nicht ganz so wie mit puren ANSI/ISO C++ klassen. die TImage komponenten werden ja unteranderem auch als __published verwaltet. wie soll das interface denn nun aussehen, damit ich auch erben kann und die beiden abgeleiteten Formulare dann die speicherverwaltung automatisch managed?

Braunstein

Was hat denn jetzt das __published damit zu tun?
Erkläre uns doch bitte mal genau was du willst. Ich zumindest, weiß jetzt nicht wo dein Problem liegt. Hast du versucht die Vorschläge die bereits gekommen sind umzusetzen? Wenn ja, was genau geht denn jetzt nicht?

witte

Du brauchst das doch nur zusammenzusetzen:

class TMyFormBase : public TForm
{
  virtual TImage* GetImage(int index) = 0;
}

TMyForm1 hat die Images in einem TImage*-Array:

class TMyForm1 : public TMyFormBase
{
  TImage* GetImage(int index) { return myImages[index]; }
}

TMyForm2 muß sie einzeln zusammensuchen:

class TMyForm2 : public TMyFormBase
{
  TImage* GetImage(int index) 
  { 
    if (index == 0) return myImage0; 
    if (index == 1) return myImage1;
    if (index == 2) return myImage2;
    if (index == 3) return myImage3;
  }
}

Und sie können einfach angefaßt werden:

myForm1->GetImage(2)->Repaint();
myForm2->GetImage(2)->Repaint();

also ich meine es vielmehr so:

class ImageInterface
{
	public:
		TImage *Image1;
		TImage *Image2;
		TImage *Image3;
		TImage *Image4;
		TImage *Image5;
		TImage *Image6;
		TImage *Image7;
		TImage *Image8;
		TImage *Image9;
		TImage *Image10;

	private:
};
//---------------------------------------------------------------------------
class TForm1 : public TForm, public ImageInterface
{
__published:	// Von der IDE verwaltete Komponenten
private:	// Anwender-Deklarationen
public:		// Anwender-Deklarationen
	__fastcall TForm1(TComponent* Owner);
};

aber VCL klassen können ja nicht mehrfach erben

ach jetzt verstehe ich eure letzten beispiele. ich muss also zuerst eine eigene Basis klasse designen und von dieser eerben dann Form1, Form2 und so weiter, ja? also:

die eigene basis klasse als interface

//deklaration
class ImageInterface : public TForm
{
	public:
		__fastcall ImageInterface(TComponent* Owner);
		__fastcall ~ImageInterface();

	private:

	__published:
		TImage *IMG1;
		TImage *IMG2;
		TImage *IMG3;
		TImage *IMG4;
		TImage *IMG5;
};
//---------------------------------------------------------------------------
class TForm1 : public ImageInterface
{
__published:	// Von der IDE verwaltete Komponenten

private:	// Anwender-Deklarationen

public:		// Anwender-Deklarationen
	__fastcall TForm1(TComponent* Owner);
	__fastcall ~TForm1();
};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

//definition
__fastcall ImageInterface::ImageInterface(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
__fastcall ImageInterface::~ImageInterface()
{
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: ImageInterface(Owner)
{
}
//---------------------------------------------------------------------------
__fastcall TForm1::~TForm1()
{
}

kommt das nun hin? so sind nun alle FormX von TForm und ImageInterface abgeleitet, oder? und somit sind dann die TImageX auch bekannt.

wenn am code nichts falsch ist, wird der speicher für die TImages auch nach wie vor automatisch freigegeben, oder?

nein? :xmas1: