Ich hoffe das ich damit jetzt kein Vogel abschiesse, aber ich weiss net wie ich es machen soll. (Zeiger, Pointer)???

Ich möchte aus einer Klasse (CBeispiel.cpp) auf den Funktion (MainCall) in main.cpp zugreifen.

Beispiel:

Datei: Main.cpp

void MainCall()
{
}

Datei: CBeispiel.cpp

--------------------

CBeispiel::CallMe()
{
  //--- Funktion in main.cpp aufrufen
  // MainCall() <----
}

Ich hoffe ihr könnte mir da helfen. :p

Datei: CBeispiel.cpp
--------------------
void MainCall();

CBeispiel::CallMe()
{
    MainCall();
}

Wenn du sowas aber öfters machen musst, bieten sich dafür Headerdateien an.

ich weiss das ich die Funktionen in einer klasse in Header Dateien defineren muß. Aber ich weiss nicht wie das hier geht.

#include <cstdlib>
#include <iostream>
#include "CBeispiel.h"

using namespace std;
CBeispiel CallTest;

void function MainCall()
{
cout << "Aufgerufen" << endl;
}

int main(int argc, char *argv[])
{

    CallTest.CallMe(); //-- <--- Hier soll MainCall aufgerufen werden aus CallMe
    				   //-- Das brauche ich weil in CallTest nach einer verarbeitung MainCall Aufrufen möchte

   system("PAUSE");
    return EXIT_SUCCESS;
}

Danke!!!

"Ich möchte aus einer Klasse (CBeispiel.cpp) auf den Funktion (MainCall) in main.cpp zugreifen."

also du hast ne klasse CBeispiel die vermutlich aufgeteilt ist ein eine .h und eine .cpp file und eine methode MainCall die nicht zu einer klasse gehört sondern im global namespace ist direkt und diese ist in main.cpp definiert

mach einfach eine main.h wo du diese funktion deklarierst also

//CBeispiel.h
#pragma once

class CBeispiel
{
    void CallMainCall();
};

//CBeispiel.cpp
#include "CBeispiel.h"
#include "main.h"

void CBeispiel::CallMainCall()
{
    ::MainCall();
}

//main.h
#pragma once

void MainCall();

//main.cpp
#include "main.h"
#include "CBeispiel.h"

void MainCall()
{
}

void main(int argc, char **argv)
{
    CBeispiel beispiel;
    beispiel.CallMainCall();
}

#include <tr1/functional>
//oder auch nur <functional>
//oder:
#include <boost/functional> //wenn du boost installiert hast (was du solltest)

class CBeispiel
{
public:
   void CallMe (std::tr1::function<void(void)> fun) //oder boost::function<void(void)>
   {
      fun();
   }
};

//...
void MainCall ();

int main ()
{
   CBeispiel foo;
   foo.CallMe(MainCall);
}

dann ersparst du dir auch das lästige herumgefrickel mit memberfunktionen (weil du einfach std::tr1::bind bzw. boost::bind verwenden kannst).

DANKE!!!!

void MainCall();

zu plazieren, hat aber mir nicht so gefallen. Weil ich nicht in Klassen so einfach Memberfunktionen reinschreiben möchte das finde ich nicht so schön.

Aber trozdem danke auch an Dich!!!

Ja ( _T ) Du hast recht es ist auch möglich in CBeispiel.cpp

void MainCall();

zu plazieren, hat aber mir nicht so gefallen.

Genau das hast du aber im Endeffekt auch gemacht. Du bindest die "main.h" ein, was einfach nur bedeutet, dass der Inhalt der "main.h" an die Stelle der #include-Zeile kommt. Also hast du auch einfach nur diese Forward-Deklaration in CBeispiel.cpp drin, nur halt über den Umweg des Prä-Prozessors. Abgesehen davon, dass "_T" schrieb Wenn du sowas aber öfters machen musst, bieten sich dafür Headerdateien an. .

evirus schrieb:

Weil ich nicht in Klassen so einfach Memberfunktionen reinschreiben möchte das finde ich nicht so schön.

Sorry, aber dieser Satz ist absoluter Unfug

Aber trozdem sind hier super möglichkeiten aufgelistet wurden und dafür bin ich sehr sehr dankbar.

Danke nochmal an alle.