wie kann man zu diesem Java-Code einen äquivalenten C++-Code erzeugen?

public class Test {

	public static void main(String[] args){
		Test t = new Test();
		t.doSomething("Hallo");

	}

	public <T extends Object> T doSomething(T t) {
		return t;
	}
}

Gruß,
CSpille

bb

halt einfach die Fresse, wenn du keine konstruktiven Ideen hast!!!

Gruß,
CSpille

halt einfach die Fresse, wenn du keine konstruktiven Ideen hast!!!

Ich empfehle dir, dich in deinem Ton etwas zu mässigen. Du bist hier Hilfesuchender. Du sollst Initiative zeigen. Hausaufgaben werden hier nicht gelöst. Das Problem ist extrem trivial, wenn man sich nur ein wenig in Templateprogrammierung auskennt.
Zeig was du versucht hast, wo und wie du gescheitert bist und wir helfen dir gerne weiter. Oder bezahle einen guten Preis und wir erledigen die Arbeit für dich.

Grüssli

ich lasse mir solche haltlosen Unterstellungen bezüglich Hausaufgaben nicht bieten.

Ist das Problem wirklich trivial, wenn der Template-Parameter nicht in der Klasse
verankert ist?
Der Template-Code wird ja zur Compilierzeit ausgewertet und wenn ich ne virtual-Funktion
habe (Methode ist nicht final), dann kann man die ja auf jedem dieser Objekttypen ausführen, folglich kann der Compiler ja gar nicht wissen, welche Typen alle
nötig sind.

Gruß,
CSpille

Hallo zusammen,

wie kann man zu diesem Java-Code einen äquivalenten C++-Code erzeugen?...

Mich (der ich mich mit java-generics nicht auskenne) würde mal interessieren, wie "äquivalent" eigentlich C++-Templates da überhaupt sein können.
Allein hiermit:

http://de.wikipedia.org/wiki/Generische_Programmierung_in_Java schrieb:

...Während in C++ über die Schnittstelle der Typparameter parametrisiert wird, wird in Java direkt über den Typ des Typparameters selbst parametrisiert....

stelle ich mir das schwierig vor.

CSpille schrieb:

...
ich lasse mir solche haltlosen Unterstellungen bezüglich Hausaufgaben nicht bieten. ...

Ich würde mir einfach überlegen, wie viel persönliche Eitelkeit in einem anonymen Forum, von dem man Hilfe erwartet und zu einem Thema, zu dem man noch gar nichts beigesteuert hat, angebracht ist.
Da kann man die Latte zwar hoch legen ... muss aber nicht.

Gruß,

Simon2.

Gar nicht so schwer, oder?
Welche Klasse?
Gruß
skrm

int main(int argc, char* argv[]) {
Test::main(argc,argv);
return 1;
}

Es ist in so weit ähnlich, als dass es maßgebnlich von C++ inspiriert ist.
Du hast recht, es ist in Java ein anderes Konzept(mehr oder weniger Typenlöschung aus Kompatipilität), aber eine gewisse Ähnlichkeit lässt sich schon feststellen.

ich finde so nen Kommentar von unskilled schon etwas unverschämt, da ich
ihm zweimal versucht habe zu helfen.

http://www.c-plusplus.net/forum/viewtopic-var-t-is-198491.html
http://www.c-plusplus.net/forum/viewtopic-var-t-is-197919.html

@skrm:

Danke für die Antwort. Ich habe irrtümlich als Modifier private geschrieben,
sollte aber public sein.

Ich bin jetzt gerade zur Arbeit gefahren, aber ich glaube so hatte ich das und sobald du die Methode virtual machst, geht das nicht mehr.
Ich werde das @home nochmal testen. DANKE DIR, skrm

Gruß,
CSpille

Hallo Simon2,

ich finde so nen Kommentar von unskilled schon etwas unverschämt, da ich
ihm zweimal versucht habe zu helfen.

lol - das ist 2 Jahre her - wie soll ich mich an so was erinnern?
außerdem war es weder bös noch sonst iwie gemeint - es kam halt einfach mal so rüber - zu mal die frage ja nu wirklich nich so schwer zu beantworten war...

bb

PS:

/*
public class Test {

    public static void main(String[] args){
        Test t = new Test();
        t.doSomething("Hallo");

    }
*/

//Test ist der Projektname, interessiert in C++ nicht
int main(int argc, char* argv[])
{
   Test t;
   t.doSomething("Hallo");
}

/*
    public <T extends Object> T doSomething(T t) {
        return t;
    }
}
*/

class Test
{
  public:
    template <typename T>
    T doSomething(T t)
    {
      return t;
    }
};

ein wenig modifiziert:

int main(int argc, char* argv[])
{
   Test t;
   t.doSomething("Hallo");
}

struct Test
{
  template <typename T>
  T doSomething(const T &t)
  {
    return t;
  }
};

allerdings ist das nicht sehr sinnvoll - also können wir auch so was machen:

int main(int argc, char* argv[])
{
   Test::doSomething("Hallo");
}

struct Test
{
  template <typename T>
  static T doSomething(const T &t)
  {
    return t;
  }
};

und jz fällt uns auf, dass wir das struct gar nicht brauchen:
auch main muss nicht so kompliziert aussehen:

int main()
{
   Test::doSomething("Hallo");
}

namespace Test
{
  template <typename T>
  static T doSomething(const T &t)
  {
    return t;
  }
};

Ansonsten: n1 Post - so erwachsen x)

*CSpille begräbt Kriegsbeil*

DANKE für deine Mühe, allerdings fehlt in diesem Fall immernoch das im
Beitrag davor angesprochene "virtual", wonach auch deine Vorschläge (wie ich denke - werde es @home testen) nicht mehr funktionieren.

Gruß,
CSpille

bb

doSomething soll virtual sein. Genau das hatte ich befürchtet
Ich hatte mir nur irgendeinen Workaround erhofft.

Gruß,
CSpille

ich lasse mir solche haltlosen Unterstellungen bezüglich Hausaufgaben nicht bieten.

Dann empfehle ich dir in Zukunft, ein bisschen mehr Eigeninitiative zu zeigen oder wie es mir in diesem Fall scheint, das Problem genauer zu beschreiben. Denn erst in diesem 3. Beitrag von dir, erfährt man, dass es dir um virtuelle Funktionen geht. Allerdings sind nicht alle Funktionen in einer C++ Klasse virtuell, im Gegenteil die Mehrheit ist es nicht.

Wenn du einfach nachgefragt hättest, ob man eine virtuellen Methode auch als Funktionstemplate implementieren kann, dann hättest du auf der Stelle eine Antwort bekommen und zwar: Nein.

Edit, da die letzten zwei Beiträge verpasst:
Falls du einen Workaround findest, bitte mitteilen. Es gibt ein paar Möglichkeiten, aber die setzen alle voraus, dass du in der Childklasse genau weisst, was da rauf kommt.

Grüssli

doSomething soll virtual sein. Genau das hatte ich befürchtet
Ich hatte mir nur irgendeinen Workaround erhofft.

du musst entweder die dynamische polymorphie durch statische ersetzen oder die statische durch dynamische.