ich habe eine Frage bzgl. Zugriff auf eine erzeugte Instanz aus einer anderen Funktion.

Im folgenden Beispiel kann ich im Timer Event nicht auf Intp1 zugreifen. Was mach ich hier falsch bzw. geht das auch ohne die Instanz global anzulegen ?

Unit1.cpp

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

int CInterpreter::c = 0;

 //---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
 CInterpreter Intp1;
 Intp1.Parser();
 Intp1.Modify_c( 1000 );
 // hier wird einiges gemacht
 Intp1.Parser();
 Timer1->Enabled = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
 Timer1->Enabled = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
 Intp1.Parser();  // Kein Zugriff
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 Close();	
}
//---------------------------------------------------------------------------

Unit2.cpp

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

#pragma hdrstop

#include "Unit2.h"
#include "Unit1.h"

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

#pragma package(smart_init)

// Definition des Konstruktors CInterpreter
__fastcall CInterpreter::CInterpreter()
{
 a = 5;
 b = 5;
}
//---------------------------------------------------------------------------

// Definition des Destruktors CInterpreter
__fastcall CInterpreter::~CInterpreter()
{
}
//---------------------------------------------------------------------------

void __fastcall CInterpreter::Parser()
{
 c += (a + b);
 Form1->ListBox1->Items->Add("P = " + IntToStr(c));
}
//---------------------------------------------------------------------------

void __fastcall CInterpreter::Modify_c( int value )
{
 c += value;
}
//---------------------------------------------------------------------------

Unit2.h

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

#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------

class CInterpreter
{
 private:
	int a, b;
	static int c;
 public:
	__fastcall CInterpreter();   // Konstruktor
	__fastcall ~CInterpreter();  // Destruktor
	void __fastcall Parser();
	void __fastcall Modify_c( int );
};
#endif
//---------------------------------------------------------------------------

sorry, da ist mir viel zu viel Überflüssiges und "Proprietäres" bei, um mich durch den Code zu wühlen (wo ist denn das "Timer Event", das "...auf Intp1 zugreifen ..." soll ? Vermutlich meinst Du "TForm1::Timer1Timer()").
Prinzipiell würde ich sagen: Du solltest Dir Gedanken bzgl. der Lebenszeit von Objekten machen: "auto-Objekte" (auch "Stackobjekte" genannt) werden nach Verlassen des Scopes (z.B. der jeweiligen Funktion) wieder abgeräumt.
Lösnug:
a) Scope weiter fassen (z.B. zu einem Member des umschließenden Objekts machen) oder
b) Objekt dynamisch ("Heapobjekt") anlegen - Nachteil: "Ownership" muss geklärt sein: Wer räumt es dann (manuell) wieder ab?

a) ist meistens die bessere Lösung - in Deinem Fall kann Intp1 anscheinend ein Member von TForm1 sein, oder ?

Gruß,

Simon2.

BTW: Deine Variablennamen sind nicht so dolle - gerade mit "Klassennummerierung" würde ich gar nicht erst anfangen.

danke für Deine Hilfe. Kannst Du mir sagen was Du genau mit a) meinst (Beispiel) ?

Und was ist an meinen Variablennamen nicht i.O. bzw. Klassennummerierung ?

Ich möchte es gerne lernen, aber ich verstehe noch nicht was Du damit meinst !

Hi Simon2,

danke für Deine Hilfe. Kannst Du mir sagen was Du genau mit a) meinst (Beispiel) ?...

Naja, irgendwo ist doch die Klassendefinition von TForm1. Sowas in der Art wie:

class TForm1 {
...
};

Da muss eben noch Dein "CInterpreter Intp1;" rein - und nicht erst in die Funktion TForm1::ButtonClick().
Dann wird das CInterpreter-Objekt names "Intp1" zusammen mit dem TForm1-Objekt angelegt (und zusammen mit ihm vernichtet) und Du hast in allen Memberfunktionen von TForm1 zugriff darauf - also auch in TForm1::Timer1Timer().
Wenn ich recht sehe, hat Du das mit "a", "b" und "c" bereits gemacht.

C++ NeuAnfänger schrieb:

Und was ist an meinen Variablennamen nicht i.O. bzw. Klassennummerierung ?

Naja, was soll mir als Außenstehendem (oder Dir, wenn Du Dir Dein Programm in 5 Jahren nochmal ansiehst) sagen, wenn da steht
a
b
c
TForm1 (Warum "1" ? Was kann die mehr als die "TForm" ? ... oder die "TForm2" ? ...
Timer1Timer (Was ist das - ein "TimerTimer" ... und besonders ein "Timer1Timer"? Gibt's auch einen "Timer2Timer"? )
...

Variablen sollte man möglichst gleich ansehen, wofür sie da sind.

C++ NeuAnfänger schrieb:

Ich möchte es gerne lernen, aber ich verstehe noch nicht was Du damit meinst !

Doppelt gut:
- Lernen wollen und
- (sinnvoll) Nachfragen.

Gruß,

Simon2.

danke nochmal für Deine Hilfe. Das hilft mir schon weiter.

P.S. a,b,c habe ich nur als Beispiel genommen. Normalerwiese nehme ich schon andere Namen.

Das nächste mal hast du hier bessere Chancen:
http://www.c-plusplus.net/forum/viewforum-var-f-is-2.html

...P.S. a,b,c habe ich nur als Beispiel genommen. Normalerwiese nehme ich schon andere Namen.

Dann ist ja gut.
(das gilt für "TForm1" und "Timer1Timer" hoffentlich auch ... )

Schön, wenn ich helfen konnte.

Gruß,

Simon2.