Superkonstruktor wie in Java

KingV1k

hi. in java kann man doch mit super auf variablen und funktionen von der aufrufenden funktion zugreifen. kennt ihr bestimmt. oder? da es in C++ so eine Möglichkeit nicht geben soll, wär meine Frage wie ich es sonst machen soll?
(bitte verständlich erklären)

Mfg
KingV1k

Ceos

ich kann mir zwar vorstellen das ich mich irre, da ich schon länger kein java mehr gemacht hab,
aber kann man mit einem superkonstruktor (super(XYZ);) nicht einfach nur im konstruktor einer abgeleiteten klasse den kontruktor der Super-Klasse (wovon abgeleitet wird) mit den entsprechenden parametern aufrufen ???
mit methoden oder funktionen hat das doch eigentlich wenig am hut ???

[EDIT] und sowas gibt es in C++ aber auch, da wird nach dem Ctor mit : einfach der Ctor der Superklasse aufgerufen

Braunstein

Da war doch letztens ein Thread dazu.
http://www.c-plusplus.net/forum/viewtopic-var-t-is-174824.html

schokomann

Wenn in Java eine Methode func() in der abgeleiteten Klasse überlagert,
dann kann man die Methode func() der Basisklasse mit super.func() aufrufen.
Beim Konstruktor ähnlich.

//pseudo-code Java

class B
{
   B( int x );
   void func();
}

class D extends B 
{
   D( int x){ super(x); }
   void func();
}

Im Programm
func() oder super.func() für Funktionen

in C++ geht so was.

// pseudo code

class A
{
public:
   A() { printf("Konstruktor A"); }

   void func(){printf( "func A" );}
};

class B : public A
{
public:
   B() : A() {} // runft Konstruktor der Basisklasse auf

   void func() { printf( "func B" );}
};

int main()
{
   B b;

   b.func(); // ruft func von Klasse B auf
   b.A::func(); //ruft func von Klasse A auf

   return 1;
}

Ist es das was Du wissen wolltest?

Simon2

KingV1k schrieb:

hi. in java kann man doch mit super auf variablen und funktionen von der aufrufenden funktion zugreifen.....

Bin zwar auch kein Java-Profi, aber das wäre mir ganz neu.
Man kann Variablen und Funktionen der Basisklasse aufrufen, aber doch nicht die aufrufende Funktion ! (Mir ist gar kein Feature bekannt, dass das in Java oder C++ anböte).

Gruß,

Simon2.

KingV1k

@schokomann ich glaube du hast mich verstanden

also ich habe grad eben einige sachen ausprobiert aber bin mit meinen nerven am ende. vielleicht könnt ihr mir ja wieder helfen

Bei mir sieht es im Moment so aus

ui_alert.h

class Ui_AlertWindow : public QObject
{
	Q_OBJECT

public slots:
	void ok()
	{
		//hier passeirt etwas
	}

main.cpp

class Funktionen
{
	private:
		//einige Variablen
                  Ui::MainWindow ui;
	public:
		Funktionen();
		~Funktionen();
		//einige andere Methoden
};

int main(int argc, char *argv[])
{
	Funktionen test;
         test.displayGUI();
	.....
	......
	......
}

void Funktionen::displayGUI()
{
    QMainWindow *window = new QMainWindow();
    test.ui.setupUi(window);
    window->show();
}

void Funktionen::ausfuehren()
{

}

das müssten eigentlich schon die wichtigsten teile gewesen sein.
Das Programm startet im main, von dort aus wird die Funktion displayGUI aufgerufen. Diese initialisiert die grafische Benutzeroberfläche. Anschließend wartet die GUI bis ein Signal zum Slot gesendet wird. Und aus diesem Slot: ok() muss die Funktion ausfuehren() aufgerufen werden. Und genau das schaff ich nicht. Ich bitte um Hilfe

Braunstein

Du mußt doch deiner Funktion Slot::ok() eine Instanz von Funktionen (hier test) übergeben um auf dessen Memberfunktionen zugreifen zu können.
Das hat hier aber doch nichts mit Vererbung (bzw. Superklassen) zu tun.

KingV1k

ich versteh zwar grad nicht was du meinst, aber hoffentlich versteht mich jemand und kann helfen

Ceos

mir wird aus deinem Code in keinster weise klar in welchem zusammenhang die Klasse Ui_AlertWindow in deiner Main verwendet wird O_o kann sein das es da einen zusammenhang gibt den ich nicht erkenne, aber müsstest du nicht irgendwo irgendwie eine instanziierung tätigen bevor überhaupt die methode ok() aufgerufen werden kann ?

Braunstein

Erklär doch mal: Was ist die Klasse slot? Ist sie von irgendwas abgeleitet? Woher stammt die Variable Slot? Ist sie evtl eine Membervariable von Funktionen?

Ceos

http://de.wikipedia.org/wiki/Signal-Slot-Konzept (Google)
scroll mal weiter runter @ braunstein, da sind sinnvollere codeschnipsel ich flieg auch grad mal drüber

Sry da blick ich jetzt so nicht durch XD vll. hilft der link irgendwie weiter ?!

KingV1k

es sieht so aus:
1. es beginnt alles in der main.cpp im main
2. dort erzeugt es das Objekt test
3. dan ruft es die Funktion displayGUI() auf
4. diese Funktion greift auf Funktionen der Datei ui_alert.h zu (in diesem schritt wird halt die grafische Benutzeroberfläche initialisiert)
5. nun führt es die restlichen Anweisungen aus der main aus
6. inzwischen wird die grafische Benutzeroberfläche schon angezeigt und diese wartet bis der User irgendetwas anklickt
7. sobald der User ein button anklickt wird das signal zum slot ok() geschickt
8. in der nun aufgerufenen Funktion ok() müsste die Funktion ausfuehren() aufgerufen werden

Punkt 1 bis 5 müssten klar sein
punkt 6 und 7 sind euch vielleicht bischen unklar. also ich benutze Qt falls es euch etwas sagt und da gibt es halt signals und slots. falls sich jemand dazu genauer interessiert: http://doc.trolltech.com/4.2/signalsandslots.html
und bei punkt 8 komm ich nicht weiter

achja könnt ihr euch zwar bestimt denken, aber ich sags zur sicherheit trotzdem in main.cpp steht als include "#include "ui_alert.h"" unteranderem

Braunstein

Dann mal eine weitere Frage an dich.
Woher soll deine Klasse Ui_AlertWindow die Instanz test der Klasse Funktionen kennen? Du mußt doch diese Klasseninstanz irgendwie übergeben.
Wenn Funktionen nur eine Art Sammelbecken für Funktionen darstellen soll ersetze sie lieber durch einen Namespace oder mache deine Funktionen darin static. Dann kannst du sie auch ohne Objekt aufrufen.

Simon2

KingV1k schrieb:

ich versteh zwar grad nicht was du meinst, aber hoffentlich versteht mich jemand und kann helfen

Also dazu könntest Du erheblich beitragen, indem Du selbst etwas exakter Dein Problem erklärst.

Bislang hat das jedenfalls weder mit "Super" noch mit "Konstruktor" noch mit "Java" zu tun. (womit vom Threadtitel lediglich "wie" und "in" übrigbleiben )
... und dass Du in Deinem Eröffnungspost von

KingV1k schrieb:

... variablen und funktionen von der aufrufenden funktion zugreifen....

sprichst, macht es auch nicht deutlicher.

Mein Vorschlag, wenn Dein Problem in der Umsetzung von Java nach C++ liegt: Zeig uns doch Deine Implementation in Java (bzw. einen sinnvollen Ausschnitt davon) !
Dann helfen hier gerne viele weiter.

Gruß,

Simon2.

Ceos

mal abgesehen von der frage von braunstein die essenziell ist!!!!

ich finde nirgendwo das

QObject::connect(button, SIGNAL(EmitMethode()), window, SLOT(Ok()));

(ich geh hier mal von einer analogie in der verwendung zum beispiel in meinem link aus)
bei dir, wie verbindest du dann das signal des button mit der slot-methode ok() =?

Dein Quellcode ist äusserst unvollständig, da sagt ein blick in die berühmte Glaskugel mehr (das war zwar zynisch aber nicht böse gemeint)

[EDIT]
Mein Vorschlag an dich wäre den Titel des Topic erstmal zu editieren und anzupassen (damit es nicht so offtopic wirkt) und dann nochmal einen detaillierteren Quellcode mit dem möglicht exakten Problem posten, sonst verheddern wir uns hier nur in unverständlichkeiten und eiern nur um deine eigentliche frage herum

KingV1k

da ich gestern schon seelisch komplett am ende war probier ich es jetzt nochmal von anfang.
also meine beiden Dateien main.cpp und ui_alert.h findet ihr unten. hätte jemand eine gute Idee wie ich den Titel dieses Topics nennen kann?

main.cpp

#include <iostream>
#include <fstream>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#include <string>
#include <QApplication>
#include "ui_alert.h"
#include <QFile>
#include <QFileInfo>
#include <QDateTime>
#include <QDir>
#include <QString>
using namespace std;

class Funktionen
{
	private:
		//hier stehen ein paar variablen

	public:
		Funktionen();
		~Funktionen();
		void ausfuehren();
		void displayGUI();
		Ui::AlertWindow alert;

};

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

	Funktionen test;
	QApplication app(argc, argv);
	test.displayGUI();
	return app.exec();
	test.~Funktionen();
}

void Funktionen::displayGUI() //diese Methode sorgt dafür das das Fenster angezeigt wird
{
	QMainWindow *window = new QMainWindow();
    	alert.setupUi(window);
	window->show();
}

Funktionen::ausfuehren()
{
	//Anweisungen	
}

Funktionen::Funktionen()
{
	//Anweisungen
}

Funktionen::~Funktionen()
{
	//Anweisungen	
}

ui_alert.h

#ifndef UI_ALERT_H
#define UI_ALERT_H

#include <QtCore/QVariant>
#include <QtGui/QAction>
#include <QtGui/QApplication>
#include <QtGui/QButtonGroup>
#include <QtGui/QFrame>
#include <QtGui/QLabel>
#include <QtGui/QMainWindow>
#include <QtGui/QPushButton>
#include <QtGui/QWidget>
#include <QObject>
#include <string>
#include <iostream>
#include <fstream>

using namespace std;

class Ui_AlertWindow : public QObject
{
	Q_OBJECT

public slots:
	void ok()
	{

		/*
		hier muss die Funktion Funktionen::ausfuehren aufgerufen werden.
		keine ahnung wie ich das machen soll.
		das war meine Frage wie ich es machen soll
                  ich habs mir so vorgestellt:
                  super.ausfuehren();
                  aber das geht ja so nicht
		*/

	}

public:
	QWidget *centralwidget;
	QPushButton *btnOk;
	QLabel *lblUeberschrift;

    void setupUi(QMainWindow *MainWindow)
    {
    MainWindow->setObjectName(QString::fromUtf8("MainWindow"));
    QApplication::setStyle("plastique");
    QFont font;
    font.setFamily(QString::fromUtf8("Arial Black"));
    MainWindow->setFont(font);
    MainWindow->setCursor(QCursor(static_cast<Qt::CursorShape>(0)));
    centralwidget = new QWidget(MainWindow);
    centralwidget->setObjectName(QString::fromUtf8("centralwidget"));

    btnOk = new QPushButton(centralwidget);
    btnOk->setObjectName(QString::fromUtf8("btnOk"));
    btnOk->setGeometry(QRect(210, 70, 75, 41));
    QFont font2;
    font2.setFamily(QString::fromUtf8("Arial Black"));
    btnOk->setFont(font2);

    lblUeberschrift = new QLabel(centralwidget);
    lblUeberschrift->setObjectName(QString::fromUtf8("lblUeberschrift"));
    lblUeberschrift->setGeometry(QRect(10, 20, 495, 21));
    lblUeberschrift->setAlignment(Qt::AlignHCenter);
    QFont font4;
    font4.setFamily(QString::fromUtf8("Arial Black"));
    font4.setPointSize(8);
    lblUeberschrift->setFont(font4);

    MainWindow->setCentralWidget(centralwidget);

    retranslateUi(MainWindow);

    QSize size(516, 132);
    size = size.expandedTo(MainWindow->minimumSizeHint());
    MainWindow->resize(size);
    MainWindow->setMinimumWidth(516);
    MainWindow->setMinimumHeight(132);
    MainWindow->setMaximumWidth(516);
    MainWindow->setMaximumHeight(132);

	QObject::connect(btnOk, SIGNAL(clicked()), this, SLOT(ok()));
	QObject::connect(btnOk, SIGNAL(clicked()), MainWindow, SLOT(close()));

    QMetaObject::connectSlotsByName(MainWindow);
    } // setupUi

    void retranslateUi(QMainWindow *MainWindow)
    {
    MainWindow->setWindowTitle(QApplication::translate("MainWindow", "Ueberschrift", 0, QApplication::UnicodeUTF8));
    btnOk->setText(QApplication::translate("MainWindow", "OK", 0, QApplication::UnicodeUTF8));
    lblUeberschrift->setText(QApplication::translate("MainWindow", "blabla", 0, QApplication::UnicodeUTF8));
    Q_UNUSED(MainWindow);
    } // retranslateUi

};

namespace Ui {
    class AlertWindow: public Ui_AlertWindow {};
} // namespace Ui

#endif // UI_ALERT_H

KingV1k

also eine möglichkeit wär ja, wenn ich in der Klasse Ui_AlertWindow die Funktion bool isclicked(); erstelle und eine variable int clicked = 0; erstelle

bool isclicked(){
	if(clicked==1){
		return true;
	}
	else{
		return false;
	}

}

und außerdem die Funktion ok() überarbeite. ungefähr so:

void ok()
{
	clicked = 1;	
}

dann kann ich in der main meiner main.cpp folgendes machen

int main(int argc, char *argv[])
{
.........
..........
.......
........
..........
...........
...........
..........
........
...........
.........
while(alert.isclicked() == false){
	//es soll so lange in der schleife bleiben, bis der button nicht geklickt wurde
	//damit es das system nicht in die knie zwingt kann ich noch eine verzögerung einbauen
}
//wenn der button endlich geklickt wurde geht er aus der schleife raus und führt die nächste anweisung aus
test.ausfuehren();

}

aber das problem auf dieser art zu lösen finde ich zu unschön

Braunstein

Inwiefern hängen QMainWindow und Ui_AlertWindow zusammen?
Nochmal, du mußt deiner Fensterklasse (sei es nun QMainWindow oder Ui_AlertWindow) eine Instanz auf Funktionen übergeben (z.Bsp. im Konstruktor). Du hast in einer Funktion keinen Zugriff auf die aufrufende Funktion (Klasse). Das Konzept mit der Superklasse aus Java beinhaltet AFAIK ja auch etwas anderes. Da geht es ja wohl um Vererbungshierarchien.
Deine Fensterklassen erben aber nicht von Funktionen und kennen deshalb auch nicht dessen memberfunktionen.
Also

class Funktionen
{
// Konstruktor etc.
  void ausfuehren()
  {}
};

class fenster
{
public:
   fenster(Funktionen* funct) : Functions(funct) {}
public slots:
    void ok()
    {
       Functions->ausfuehren();
    }
private:
    Funktionen* Functions;
// Rest
};

KingV1k

ok. gut ich habe jetzt mein code dementsprechend verändert. aber ich bekomme jetzt compilerfehler:
ui_alert.h:58: error: ISO C++ forbids declaration of Funktionen' with no type ui_alert.h:58: error: expected;' before '*' token
ui_alert.h:61: error: expected )' before '*' token ui\_alert.h: In member functionvoid Ui_AlertWindow::ok()':
ui_alert.h:31: error: `Functions' undeclared (first use this function)
ui_alert.h:31: error: (Each undeclared identifier is reported only once for each function it appears in.)

31: Functions->ausfuehren();
58: Funktionen* Functions;
61: Ui_AlertWindow(Funktionen* funct) : Functions(funct){}

leigt der Fehler vielleicht darin das meine beiden Klassen sich in unterschiedlichen Dateien befinden?

Braunstein

Ja.
Du solltest den Header, wo Funktionen deklariert wurde mit einbinden.