# C++ zu JAVA



## guguli (28. Aug 2014)

Hallo zusammen,

ich hab ein kleines Problem, ich möchte gerne einen C++ Code zu JAVA umschreiben, jedoch kenn ich mich mit C++ nicht so gut aus. Kann mir einer vllt dabei helfen den Code zu verstehen ...

THX

Der Code fängt so an :


```
#include <iostream>
#include <vector>
#include <stdio.h>

// read in line
std::string ReadTxtLine(FILE *pFile)
{
  char cToken;
  int iBufSize = 256;
  int iIncrement = 256;
  char *pBuf = (char*)malloc(sizeof(char)*iBufSize);
  int iCounter = 0;
  
  memset(pBuf, 0, sizeof(char)*iBufSize);

  while(!feof(pFile))
  {
    fread(&cToken, 1, 1, pFile);
    if(cToken == '\n')
      break;

    pBuf[iCounter++] = cToken;
    if(iCounter == iBufSize)
    {
      pBuf = (char*)realloc(pBuf, sizeof(char)*(iBufSize+iIncrement));
      memset(&pBuf[iCounter], 0, sizeof(char)*iIncrement);
      iBufSize += iIncrement;
    }
  }
  std::string strLine = pBuf;
  free(pBuf);
  return strLine;
}
```

dann kommt die Klasse :

```
// class for converting a single 2D comsol file
class ComsolFile2D
{
public:
  enum eDATA
  {
    TEMPERATURE,
    VELOCITY_X,
    VELOCITY_Y,
    POLY_VOL
  };

  // read in
  void ReadIn(char *pFileName, std::vector<eDATA> *pOrder, int iIndex, bool fTempInCelsius);

  // save data as vtk
  void SaveToVTK(char *strOutputFolder);
  
  // remove points
  void RemovePoints(std::vector<int> arrPoints);
....
```

Kann einer mir erstmal bis hier sagen was da passiert ???

THX


----------



## Flown (28. Aug 2014)

```
#include <iostream>
#include <vector>
#include <stdio.h>

// read in line
std::string ReadTxtLine(FILE *pFile)
{
  // Ein Zeichen
  char cToken;
  // Buffersize definieren
  int iBufSize = 256;
  // Buffersize Inkrementierungsschritt festlegen
  int iIncrement = 256;
  // Allokieren des Speichers für char-Array
  char *pBuf = (char*)malloc(sizeof(char)*iBufSize);
  // Anzahl bereits gelesener Zeichen
  int iCounter = 0;
  
  // Alle Stellen im allokierten Array auf 0 setzen
  memset(pBuf, 0, sizeof(char)*iBufSize);

  // Schleife solange nicht das Ende des Files erreicht ist
  while(!feof(pFile))
  {
    // Ein Zeichen aus dem pFile in cToken lesen
    fread(&cToken, 1, 1, pFile);
    // Wenn das Zeichen eine newLine ist, dann wird die Schleife abgebrochen
    if(cToken == '\n')
      break;

    // Setzen des Zeichens im allokierten Array an der richtigen Leseposition
    pBuf[iCounter++] = cToken;
    // Wenn der Buffer zu klein wird, dann den Speicher für das Array erhöhen
    if(iCounter == iBufSize)
    {
      // Reallokierung des Arrayspeichers
      pBuf = (char*)realloc(pBuf, sizeof(char)*(iBufSize+iIncrement));
      // Jede Stelle des angehängten Speichers auf 0 setzen
      memset(&pBuf[iCounter], 0, sizeof(char)*iIncrement);
      // Neue Buffersize setzen
      iBufSize += iIncrement;
    }
  }
  // Char-Array auf ein String mappen
  std::string strLine = pBuf;
  // Den allokierten Speicherplatz freigeben
  free(pBuf);
  // Den String zurückgeben
  return strLine;
}
```

Die andere Klasse ist sozusagen ein Interface.


----------



## Ice (24. Sep 2014)

Es wird eine Datei ausgelesen und dann in eine andere Datei geschrieben


----------

