# Programm von C++ auf Java umschreiben



## C2J (18. Jan 2013)

Hallo!

Ich beschäftige mich zur Zeit damit ein Programm von C++ auf Java umzuschreiben.

Es gibt an einigen Stellen Probleme... aber keine Sorge ich frag alles nach und nach

meine erste Frage ist: 

in einem der Header wird     
	
	
	
	





```
typedef unsigned long Half;
```
definiert.
und später in einer Struktur 
	
	
	
	





```
Half e_type;
                                               Half e_machine;
```

bei einer anderen Funktion 
	
	
	
	





```
virtual Half  GetType()  const =0 
                                              virtual Halft GetMachine() const = 0
```

In Java hab ich das so geschrieben:

```
public short e_type;
	                                        public short e_machine;
```

und bei der Funktion :      
	
	
	
	





```
short getClass();
                                            short GetMachine();
```


bei GetMachine() is alles ok aber bei getClass() schmeißt der mir nen Fehler raus? "The return type is incompatible with Object.getClass()"


Ich hoffe ich konnte das halbwegs klar machen! es sind verschiedenen Dateien und ich hab erst Code-Fetzen deshalb kann musste ich das so komisch zusammensetzen.

Vielen Dank schonmal!

Gruß


----------



## Marco13 (18. Jan 2013)

Die Methode "getClass" gibt es schon in der Klasse "Object" (von der alle Klassen erben). D.h. dort versuchst du, eine Methode zu überschreiben - aber mit einem anderen Rückgabetyp (aber auch sonst sollte man die nicht überschreiben - ich denke, die ist auch final). 

Nenn' die Methode nicht getClass sondern ... getMachineClass oder wie auch immer....


----------



## musiKk (18. Jan 2013)

Marco13 hat gesagt.:


> (aber auch sonst sollte man die nicht überschreiben - ich denke, die ist auch final).



Ist sie. Vor dem Hintergrund wäre eine Fehlermeldung à la "cannot override final method" wahrscheinlich hilfreicher gewesen. Tatsächlich kommt dieser Fehler bei Eclipse erst zuletzt. Versucht man z. B. eine [c]Class<?> getClass()[/c] zu implementieren, lautet der Fehler "cannot reduce visibility..."


----------



## Tobse (18. Jan 2013)

Darf ich fragen, warum du einen [c]unsigned long[/c] in einen 
	
	
	
	





```
short
```
 übersetzt? Java ist ja (leider) nicht in der Lage, unsigned-typen zu erstellen.


----------



## pro2 (18. Jan 2013)

Tobse hat gesagt.:


> Darf ich fragen, warum du einen [c]unsigned long[/c] in einen
> 
> 
> 
> ...




```
char
```
 wäre unsigned, aber der ist ja eher nicht zum Rechnen gedacht.


----------



## Tobse (18. Jan 2013)

pro2 hat gesagt.:


> ```
> char
> ```
> wäre unsigned, aber der ist ja eher nicht zum Rechnen gedacht.



Ein 
	
	
	
	





```
char
```
 ( = 
	
	
	
	





```
short
```
) hat 16bit, ein 
	
	
	
	





```
long
```
 64.


----------



## Gast2 (18. Jan 2013)

Tobse hat gesagt.:


> Java ist ja (leider) nicht in der Lage, unsigned-typen zu erstellen.



in dem Moment wo Du es schaffst die Matrix zu beeinflussen, dann schaffst Du auch eine 255 in einem Byte zu speichern


----------



## Tobse (18. Jan 2013)

mogel hat gesagt.:


> in dem Moment wo Du es schaffst die Matrix zu beeinflussen, dann schaffst Du auch eine 255 in einem Byte zu speichern



Haha dann kann ich die Matrix beeinflussen 
[c]-1dec = 1111 1111bin[/c]
kommt halt drauf an, was Java dann daraus macht :/


----------



## Gast2 (18. Jan 2013)

Tobse hat gesagt.:


> kommt halt drauf an, was Java dann daraus macht :/



nein - es kommt nur darauf an was in Deinem Kopf vor sich geht.


```
255dec = 1111 1111bin
```


----------



## piu58 (19. Jan 2013)

>  (leider) nicht in der Lage, unsigned-typen zu erstellen

Ich emfinde das nicht als "leider". DIeser ganze Typenwahnsinn unter C/C++ kostet doch Nerven. Und int unter java bietet doch für fast alle Fälle einen genügend großen Zahlenraum. Unsigned ist ein Krücke, um mit 8- oder 16-bit-Zahlen halbwegs hinzukommen.


----------



## Gast2 (19. Jan 2013)

piu58 hat gesagt.:


> DIeser ganze Typenwahnsinn unter C/C++ kostet doch Nerven.



ja - aber C/C++ Compiler sind für alle möglichen Typen von Prozessoren, von 8 bis 64 Bit. Das spiegelt auch irgendwie der Standard wieder.

[DUKE]short(2 Bytes) <= int (2 oder 4 Bytes) <= long (4 oder 8 Bytes)[/DUKE]
auf Grund der Standart Datentypen kannst Du gar nicht wissen (durch reines betrachten des Quelltextes) wieviel Bytes Dein int gerade verbraucht bzw. kann. Lustig wird es wenn ein Sytemadmin im Hintergrund den Compiler aktualisert, der Hersteler für int statt der 2 Byte plötzlich 4 Bytes wählt und Dein Programm nicht mehr in der Prozessor passt.

Bei uint8, uint16 bzw. uint32 weist Du zumindest im Quelltext das es immer 8, 16 oder 32 Bit sind.


----------



## Tobse (19. Jan 2013)

piu58 hat gesagt.:


> für fast alle Fälle


Ja eben genau das. Wenn ich einen Zahlenraum von 0-50.000 abdecken will in einer Klasse die möglicherweise 5.000-10.000 mal gleichzeitig instantiiert ist, dafür aber ein int nehmen muss, weil es kein 
	
	
	
	





```
ushort
```
 gibt macht das am Ende ganz schön was her. Kleinvieh macht auch mist.
Ausserdem ist das fehlen von unsigned-Typen daran Schuld, dass Java nur Dateien bis 2GB bearbeiten kann...


----------



## Gast2 (19. Jan 2013)

Tobse hat gesagt.:


> Wenn ich einen Zahlenraum von 0-50.000 abdecken will in einer Klasse die möglicherweise 5.000-10.000 mal gleichzeitig instantiiert ist, dafür aber ein int nehmen muss, weil es kein
> 
> 
> 
> ...


wow - 20kB bei (min.) 2GB gesamt Speicher.



> Kleinvieh macht auch mist.


sicher



> Ausserdem ist das fehlen von unsigned-Typen daran Schuld, dass Java nur Dateien bis 2GB bearbeiten kann...


sorry - aber das ist eindeutig eine Designfehler von ${WerAuchImmerAufDieIdeeKam}. C# nimmt dort long, genau so wie die POSIX-Implementierung.


----------



## Tobse (19. Jan 2013)

mogel hat gesagt.:


> wow - 20kB bei (min.) 2GB gesamt Speicher.


Ja stimmt schon, ist nicht viel aber etwas 


mogel hat gesagt.:


> sorry - aber das ist eindeutig eine Designfehler von ${WerAuchImmerAufDieIdeeKam}. C# nimmt dort long, genau so wie die POSIX-Implementierung.


Ja. Hätte man bei Java wenigstens ein uint genommen wärens schon 4GB.

Ist ja auch egal, ich vermisse die unsigned-datentypen manchmal einfach.

@Topic:
Faktisch kann aber ein 
	
	
	
	





```
short
```
 nicht das speichern, was ein 
	
	
	
	





```
ulong
```
 kann. Nur als Tipp


----------



## KuhTee (19. Jan 2013)

mogel hat gesagt.:


> wow - 20kB bei (min.) 2GB gesamt Speicher.


Vor 7 Jahren hatte ich bei der Entwicklung mit Java (J2ME) noch um ein Bruchteil dieses Wertes gekämpft, und zwar mehrere Tage. Und auch heute noch gibt es Geräte mit Java, wo der Speicherverbrauch nicht unerheblich sein kann.



Tobse hat gesagt.:


> @Topic:
> Faktisch kann aber ein
> 
> 
> ...


Ja, selbst wenn man den Unterschied zwischen signed und unsigned nicht kennt, ist es schon merkwürdig, für etwas was "long" heisst einen "short" zu nehmen, wo doch Java selbst auch einen Datentyp kennt, der "long" heisst


----------



## Marco13 (19. Jan 2013)

mogel hat gesagt.:


> Das spiegelt auch irgendwie der Standard wieder.
> 
> [DUKE]short(2 Bytes) <= int (2 oder 4 Bytes) <= long (4 oder 8 Bytes)[/DUKE]



<halbwissen>
Soweit ich weiß (!) ist im echten C-Standard praktisch GAR nichts in bezug auf "echte Größen" festgelegt ... ich hatte da mal gesucht, und meine (!) da stünde am Ende nur (sehr verklausuliert) : Ein char hat die Größe einer Adressierungseinheit, und alle anderen (short, int, long...) sind mindestens so groß wie char. Wenn nun jemand einen Prozessor baut, der Nibbles für die Addressierung verwentet, kann es - falls ich das richtig verstanden und in Erinnerung habe - sein, dass der C-Compiler dafür einfach char=short=int=long=4bit festlegt, und nichts aus dem C-Standard würde ihn daran hindern. 
</halbwissen>


----------



## piu58 (19. Jan 2013)

Im C-Standard ist festgelegt, das short<=int<=long und das int die prozessortypische Größe ist, womit also die Recheneinheit am besten klar kommt.

C ist so ne Art maschinenunabhängiger Assembler.


----------



## C2J (25. Jan 2013)

Danke euch für die Hilfe! (sry für meine später antwort!)

@Marco13: Werde ich mal so machen! Danke dir!



> Darf ich fragen, warum du einen unsigned long in einen short übersetzt? Java ist ja (leider) nicht in der Lage, unsigned-typen zu erstellen.



Ich hab mir darüber keinen Kopf gemacht! Sehr cool wie das hier eine Grundsatzdiskussion losgetreten hat 
dann nehm ich einfach .long ... der Speicherplatz ist mir jetz erstmal egal


----------



## C2J (25. Jan 2013)

Ich habe noch eine weitere Frage:

In einer Header Datei werden mehrere Klassen deklariert. Also mache ich in Java eine Klasse, von der alle diese Unterklassen erben!

In denen Unterklassen stehen so lustige Sachen wie:
	
	
	
	





```
virtual Unterklasse1_Err Load( const std::string& sFileName )        = 0;
    virtual Unterklasse1_Err Load( std::istream* pStream, int startPos ) = 0;
```

virtual gibt es nicht.ich habs übersetzt mit: 
	
	
	
	





```
Unterklasse1_Err Load(String sFileName);
```

Bei der zweiten Zeile habe ich jetz das problem das ich die Variable istream* noch nich verstehe.

Ich weiß das es ein Input ist. Soll ich dann einfach einen in der Oberklasse schreiben den die Unterklassen erben? 
	
	
	
	





```
BufferedReader istream = new BufferedReader(new InputStreamReader(System.in));
```

oder n neues package aufmachen und darauf zugreifen mit 
	
	
	
	





```
neuespackage.istream
```

Ich hab immer Sorge das ich dadurch den Sinn verändere.
Heißt istream das das ne Nutzereingabe ist oder is das irgend ein anderer Input?

Danke euch! 
Gruß


----------



## Marco13 (25. Jan 2013)

C2J hat gesagt.:


> Heißt istream das das ne Nutzereingabe ist oder is das irgend ein anderer Input?



Ja   Genau das  : Nutzereingabe - ODER irgendein (!) anderer Input. Am ehesten würde man das direkt mit einem InputStream übersetzen. Das 'startpos' ist da schon schwieriger, da müßte man ggf. genauer wissen, was das ist und wie das verwendet werden soll.


----------



## C2J (25. Jan 2013)

Ahh das ist wunderbar dann brauch ich mich nicht entscheiden..sonst würde ich womöglich hinterher eine Nutzereingabe vorgeben und es ist keine 

Ich merke mir ist mehr geholfen mich ersteinmal daran zu begeben GENAU zu verstehen was das Programm wann wo tut...
Sonst enstehen immer mehr so Fragen.
Und dann schreib ich es ganz neu. Weil wenn ichs nur übersetzte muss ich die Struktur von dem *Herrn* übernehmen der das in C++ geschrieben hat 

Hoffe ich kann euch weiter mit Fragen bombadieren. Mein bester Freund bleibt zwar Google aber spezifische Fragen habt ihr mir super schnell beantwortet für die ich sonst 10 tutorials auswendig gelernt haben müsste von denen 3 nichtmal passend sind.

In diesem Sinne


----------



## C2J (25. Jan 2013)

Direkt das Erste: 
Ich finde bei Google nur USERFORM()   hier steht aber USEFORM ("blaaaaa", Form1); im Code?!?!


----------



## Spacerat (25. Jan 2013)

C2J hat gesagt.:


> Ich merke mir ist mehr geholfen mich ersteinmal daran zu begeben GENAU zu verstehen was das Programm wann wo tut...


Das ist ein guter Vorsatz... Leider müsste man dazu zumindest die Sprache kennen, von welcher man konvertieren oder ganz pragmatisch Funktionalitäten stibitzen will.
Aber es gibt Leute (wie mich z.B.) die machen das ganz anders, die lernen genau jene Sprache, die dem Maschinencode am nächsten kommt, nämlich Assembler. Dann nehmen sie sich einen Recompiler wie IDAPro und versuchen damit ihr Glück. Das hat dann zwar so gesehen nichts mehr mit der Sprache zu tun, in welcher das Programm einst entwickelt wurde, aber das wird zunehmend egal.
BTW.: "USEFORM()" könnte bereits was API spezifisches sein, evtl. ein Verweis auf die Form einer zuvor erstellten GUI (VisualC++; "USERFORM()") die man verwenden möchte.


----------



## Marco13 (25. Jan 2013)

Man sollte es grundsätzlich hinterfragen, wenn APIs 1:1 in andere Sprachen übersetzt werden (jaja, ich weiß, das sagt der richtige  ). Spätestens, wenn in dem C-Teil irgendwas mit Pointern oder Referenzen oder Structs vorkommt, wird die direkte Übersetzung nach Java ggf. schwierig.


----------



## Spacerat (25. Jan 2013)

Marco13 hat gesagt.:


> Man sollte es grundsätzlich hinterfragen, wenn APIs 1:1 in andere Sprachen übersetzt werden...


1:1 fällt bei Assembler z.B. komplett aus (Emulatoren mal aussen vor). Wichtig ist nur, dass man herausfindet, wie das ein oder andere funktioniert. Wenn man da dann hinter gekommen ist, ist's gar nicht mehr nötig alles 1:1 übernehmen zu müssen, weil in der Zielsprache gibt's definitiv andere, evtl. sogar bessere Wege, das herausgefundene zu realisieren. Genau darin liegt die Kunst der Konvertierung (Ich denke mal nicht, dass z.B. in Quaxlis Tutorial noch eine einzige Zeile Original "Falcon Patrol II"-Code enthalten ist).
Lustigerweise, lernt man durch IDAPro einige Sprachen (z.B. C/C++) von einer ganz anderen Seite kennen und freut sich urplötzlich, dass sein eigenes Programm nicht so "starr dämlich" (sondern evtl. nur "dämlich") von einem Kompiler übersetzt wurde, weil ja noch ein dazwischen hängender JIT ständig optimiert und ein eben solcher GC hin und wieder aufräumt, wenn er mag.


----------



## C2J (25. Jan 2013)

Verstehe ich das richtig der folgende Befehl einfach nur die Länge eines long ausliest und zurückgibt??


```
AnsiString aLongToStr(long value) {
  return AnsiString(value);
}
```


----------



## Spacerat (25. Jan 2013)

Stefan Raab hat gesagt.:
			
		

> Man weis es nicht.


Normalerweise gibt es ja so'n "sizeOf()"-Konstrukt dafür. Ich tippe mal eher, dass dort ein String aus einer Liste an Position "value" zurückgegeben wird.


----------



## Gast2 (27. Jan 2013)

C2J hat gesagt.:


> In einer Header Datei werden mehrere Klassen deklariert.


*pfui* - dafür gibt es Verzeichnisse und auf Wunsch sogar noch Namespace



> Also mache ich in Java eine Klasse, von der alle diese Unterklassen erben!


nur wenn in der Header das auch so ist



> In denen Unterklassen stehen so lustige Sachen wie:
> 
> 
> 
> ...




```
public interface Variante1 {
    public Unterklasse1_Err Load(String sFileName );
    public Unterklasse1_Err Load(Stream pStream, int startPos );
}
```

oder


```
public abstract class Variante2 {
    ...
    public abstract Unterklasse1_Err Load(String sFileName );
    public abstract Unterklasse1_Err Load(Stream pStream, int startPos );
    ...
}
```

hand, mogel


----------

