main-Methode in Main-Klasse packen

[Jay1980]

Servus,

gutes Neues erstmal.

Ich versuche ein Java-Programm nach C++ zu portieren und im Java-Code habe ich die Main-Klasse mit der main-Methode. Nun fasst meine Main-Klasse aber auch einige Attribute - wie kann ich diese nach C++ bringen - meine IDE (Netbeans) legt mir die main-Methode standardmäßig nicht als Klasse an?

Also Java: Klasse Main mit Attributen und main-Methode soll nach C++ - wie mache ich das?

Danke vorab.

[Bashar]

Mal angenommen, dass dieses Unterfangen überhaupt sinnvoll ist, ganz einfach: Du packst die main-Methode in eine Main-Klasse und rufst sie von der main-Funktion auf.

[knivil]

Lege doch in der main-Funktion dein Main-Objekt an und rufe dort deine main-Methode auf.

[Paul Müller]

In C++ ist main keine Methode, sondern eine Funktion. Ist aber auch nicht weiter schlimm, wenn du nur so wenn wie nötig am Code ändern willst, dann rufst du in main einfach deine Methode auf.

[Paul Müller]

knivil schrieb:

Lege doch in der main-Funktion dein Main-Objekt an und rufe dort deine main-Methode auf.

Da in Java die main-Methode statisch ist und dass die selbe Bedeutung wie in C++ hat, benötigt man kein Objekt.

class Klasse
{
public:
    static void main(std::array<std::string> & args)
    {
    }
};

int main(int argc, char ** argv)
{
    std::array<std::string> args;
    // hier argv in args kopieren
    Klasse::main(args); // hier rufst du main 
    return 0;
}

[Paul Müller]

std::array --> std::vector

[Jay1980]

Servus, ich habe es nun mal so probiert, bin gespannt ob ihr das ok findet und mir sagen könnt was ich noch falsch gemacht habe - bin C++-Neuling. Ich habe wie oben angedeutet versucht einfach eine Javamain-Klasse anzulegen. In der main.cpp-Datei soll dann eine Instanz der Javamain-Klasse erzeugt werden - dann sollten ja alle relevanten Daten da sein. Leider kompiliert es nicht so, wie ich will.

Fehlermeldung Compiler
main.cpp: In function ‘int main(int, char**)’:
main.cpp:21: error: request for member ‘getReturnString’ in ‘javamain’, which is of non-class type ‘Javamain()’
make[2]: *** [build/Debug/GNU-Linux-x86/main.o] Fehler 1

Datei: main.cpp

#include <cstdlib>
#include <iostream>
#include <string>
#include "javamain.cpp"

using namespace std;

/*
 * 
 */
int main(int argc, char** argv) {

    Javamain javamain(); // = new Javamain();
    string einString = javamain.getReturnString();
    cout << einString << endl;

    return 0;
}

Datei javamain.cpp

#include "javamain.h"
#include <iostream>

using namespace std;

Javamain::Javamain(){
    cout << "Javamain.cpp bin da";
    // TODO auslagern in Konfigurationsdatei
    rstr = "\n Rückgabestring!";
    user = "Jochen Bauer";
    filename = "msa4x4.aln";
    dbglevel = "0";
    msaName = "Example 4x4";
    alnDir = "/home/jay/Desktop/";

}

string Javamain::getReturnString( void ){
    return rstr;
}

Datei javamain.h

#ifndef JAVAMAIN_H
#define	JAVAMAIN_H

#include <string>

// Breymann2009 S. 133, S. 162f

class Javamain {

public:
    Javamain();
    std::string getReturnString( void );

private:
    std::string rstr; // returnstring
    std::string user; // Konfiguration: Properties-Objekt
    std::string filename;
    std::string dbglevel;
    std::string msaName;
    std::string alnDir;

};

#endif	/* JAVAMAIN_H */

Danke vorab fürs Feedback.

[drakon]

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

    Javamain javamain; // = new Javamain(); 
    string einString = javamain.getReturnString(); 
    cout << einString << endl; 

    return 0; 
}

Ohne die Klammern bei javamain.

Javamain javamain();

ist eine Funktionsdeklaration einer Funtion mit Rückgabetyp Javamain und ohne Parameter und keine Instanzierung eines Objektes.

[non-class]

Dass du auf

Javamain *javamain = new Javamain();

verzichtet hast, spricht für dich.

Javamain javamain();

Das war fast korrekt, du musst nur noch auf die störenden Klammern verzichten:

Javamain javamain;

Generell so als Tipp: versuche nicht unbedingt, die Java-Angewohnheiten direkt zu übernehmen, die char *argv[] kannst du ruhig als solche belassen, weil es in C++ oft unnötig ist, daraus einen vector<string> zu machen.

Wenn es dich nicht allzu fest stört, verzichte auch noch auf das using namespace std; (in Headern ist das sowieso Pflicht) und auf die <cstdlib> , wenn das nicht unbedingt sein muss.

[Jay1980]

Ok danke es scheint aber schon noch diverse weitere Fehler zu geben. Die Klammern schrieb ich weil ich dachte, so ruft man den Standardkonstruktor auf, naja muss ich nochmals nachlesen ...

[Manni66]

Das #include "javamain.cpp" in main.cpp ist falsch. Ersetze .cpp durch .h .

[Panke]

Meine Grundregel: Keine unnötigen Klammern bei Objekterzeugungen. Dann ist man auf der sicheren Seite und gleich noch konsistent.
Denn

Klasse* object = new Klasse(); // erlaubt
Klasse object(); // Funktionsdeklaration autsch

// aber 
Klasse* object = new Klasse; // auch erlaubt
Klasse object; // so gehts.

Der Standardkonstruktor wird immer aufgerufen, wenn Du ein Objekt eines benutzerdefinierten Typs erzeugst
und Parameter weglässt. Anders ausgedrückt: Irgendein Konstruktor wird immer ausgeführt.

[Nexus]

Panke schrieb:

Der Standardkonstruktor wird immer aufgerufen, wenn Du ein Objekt eines benutzerdefinierten Typs erzeugst
und Parameter weglässt. Anders ausgedrückt: Irgendein Konstruktor wird immer ausgeführt.

Nein, das stimmt so nicht. Benutzerdefinierte Typen sind ja nicht nur Klassen, aber selbst bei Klassen ist das Verhalten nicht so, wie du es beschreibst.

enum E { ... };       // benutzerdefinierter Typ
E e;                  // kein Konstruktoraufruf

Bei den Klassen ist das Verhalten speziell, wenn es sich um POD-Typen (Plain Old Data) handelt.

struct S { int x; };  // POD-Klasse
S s;                  // Initialisierung

int main()
{
    S s;              // KEINE Initialisierung
    S t = S();        // Initialisierung

    S* u = new S;     // KEINE Initialisierung
    S* v = new S();   // Initialisierung
}

[drakon]

@Nexus
Das was du in dem zweiten Code Stück beschreibst hat aber imo nicht viel mit Standardkonstruktor oder nicht zu tun. Irgendein Konstruktor wird immer aufgerufen, aber macht halt möglicherweise nichts (oder nicht das, was man vielleicht meinen könnte, wie die Initialisierung). Wenn man einen Standardkonstruktor definiert wird der von allen Versionen genau gleich aufgerufen.
Dass die Version mit und die ohne Klammern gleich sind hat ja niemand behauptet.

[krümelkacker]

Jay1980 schrieb:

Servus, ich habe es nun mal so probiert, bin gespannt ob ihr das ok findet und mir sagen könnt was ich noch falsch gemacht habe - bin C++-Neuling. [...]

Fehlermeldung Compiler
main.cpp: In function ‘int main(int, char**)’:
main.cpp:21: error: request for member ‘getReturnString’ in ‘javamain’, which is of non-class type ‘Javamain()’
make[2]: *** [build/Debug/GNU-Linux-x86/main.o] Fehler 1

Datei: main.cpp

#include <cstdlib>
#include <iostream>
#include <string>
#include "javamain.cpp"

Pfui! Man bindet keine cpp-Dateien ein. Du müsstest Dich mit dem Konzept der getrennten Übersetzung auseinandersetzen.

Jay1980 schrieb:

using namespace std;

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

    Javamain javamain(); // = new Javamain();

Hier deklarierst Du eine Funktion namens javamain. Lass die Klammern weg.

Jay1980 schrieb:

Datei javamain.cpp

#include "javamain.h"
#include <iostream>

using namespace std;

Javamain::Javamain(){
    cout << "Javamain.cpp bin da";
    // TODO auslagern in Konfigurationsdatei
    rstr = "\n Rückgabestring!";
    user = "Jochen Bauer";
    filename = "msa4x4.aln";
    dbglevel = "0";
    msaName = "Example 4x4";
    alnDir = "/home/jay/Desktop/";
}

Recherchiere C++ "initialization list"

Jay1980 schrieb:

string Javamain::getReturnString( void ){
    return rstr;
}

Datei javamain.h

#ifndef JAVAMAIN_H
#define	JAVAMAIN_H

#include <string>

// Breymann2009 S. 133, S. 162f

class Javamain {

public:
    Javamain();
    std::string getReturnString( void );

private:
    std::string rstr; // returnstring
    std::string user; // Konfiguration: Properties-Objekt
    std::string filename;
    std::string dbglevel;
    std::string msaName;
    std::string alnDir;
};

#endif	/* JAVAMAIN_H */

Aha. Einen Header hast Du auch noch. Warum bindest Du den nicht per #include in main.cpp ein?

kk

[Panke]

@Nexus
Der feine Unterschied bei PODs war mir nicht bewusst. Danke für den Hinweis.