8 Zeichen eines Strings

[Michael__W.]

Hallo !

Ich möchte einen String belibieger Länge mit einer for-Schleife durchlaufen, die immer 8 Bytes/Zeichen des Strings an eine Funktion übergibt. Hinterher werden dann die Rückgaben aus der Funktion mit strcat wieder zu einem langen String zusammengefügt. Ich bin jetzt allerdings überfordert mit der for-Schleife, oder gibt es da vielleicht eine andere Möglichkeit.

Soll in etwa so aussehen ...

char *input   // Ganzer Eingabestring
char *output //  Ganzer Ausgabestring

/* for-Schleife

   für jede 8 Zeichen 
     -> zur Funktion
     strcat (hänge die 8 Zeichen Rückgabe der Funktion an den Ausgabestring *output)

*/

Würde mich über jede Hilfe freuen. Auch Denkanstöße sind sehr willkommen.

[dEUs]

Hm? Was hatn das mit der MFC zu tun? -> C++

[Michael__W.]

dEUs schrieb:

Hm? Was hatn das mit der MFC zu tun? -> C++

Sorry, im Grunde genommen nicht viel. War nur so auf dieses Forum fixiert.

Frage bleibt dennoch bestehen, wie kann ich denn einen in 8-Byte-Häppchen an eine Funktion übergeben ?

[Mis2com]

Hm? Was hatn das mit C++ zu tun? -> C

[davie]

denkanstoß:
wenn die funktion acht bytes, nicht nullterminiert, erwartet, wie wäre es dann, wenn du
input, input+8, input+16 etc. als char* übergibst?

[rüdiger]

@davie
du musst nur aufpassen, wenn die Länge des Strings nicht durch 8 Teilbar ist

[davie]

ist ja auch nur ein denkanstoß
aber ja, hätt' ich dazu sagen sollen

[PAD]

Hier eine mögliche Lösung in C, da das Ziel C oder C++ nicht definiert ist, und das folgende auch unter C++ kompiliert.

int testfunktion(char *input,char *output, int outputlen)
{
 char WorkStr[8+1]; // das +1 ist eine Marotte  
                    // von mir um den üblichen Fehler zu vermeiden das für 
                    // die schließende Null kein Platz mehr da ist. 
 char ReturnWorkStr[1024+1] // diesen String bitte ausreichen groß für das Problem anlegen
 int n;             // Anzahl der Achterpäcken, das letzte Päcken kann weniger
                    // als 8 Bytes beinhalten.
 int i,j;           // Zwei Schleifenindices
 int Error=0;       // Variable fürs Fehlerhandling
 int len;           // Länge des Inpoutstring

 output[0]=0x0      //  Mach den Outputstring leer
 len=strlen(input); //  Bestimme die Länge des Inputstrings
 n =int((double)len/ 8.0 + 0.5 ); // berechne die Anzahl der 8 Päcken
 if ((n*8)!=len)
  {
   // Hier Fehlerhandling falls die Länge des InputStrings nicht durch 8 teilbar ist
  }
 for (i=0;i < n ;i++)  // Bearbeite die Inputstring
  {
   for (j=0;j<8;j++)   // Kopier eine 8tet Päckchen nach work
     WorkStr[j]=input[(i*8)+j]; 
   WorkStr[8]=0x00;    // Mache eine echten String daraus

   Error=call_any_funktion(WorkStr,ReturnWorkStr) // Bitte beachten in WorkStr passen nur 8 Zeichen
                                                  // ReturnWorkstr muß groß genug definiert sein um das Ergebnis aufzunehmen
   if( 0!=Error)
    {
     // Error handling nicht vergessen
    }
   if ( (strlen(output)+8)   <= outputlen)
     strcat(output,returnworkstr)  // Hänge es an de Output an 
   else
    {
     // Fehlerhandling Outputstring ist zu kleine
    }
return 0;                                         // 0 == Alles ok
}

[_Stefan]

Hab mal folgendes gebaut.

char *split(char *begin,int laenge)
{
   int i;
   static char *start=begin;
   char *ret = new char[8];
   for(i=0;i<8&&start-begin<laenge;i++) ret[i]=start[i];
   start+=i;
   ret[i-1]+='\0';
   return ret;
}

[Jester]

So, damit wir auch noch ne C++ Lösung haben...

#include <string>

std::string Work(const std::string & text)
{
  std::string result;
  for(int i=0; i<text.length(); i+=8)
      result += DoSomething(text.substr(i,8));
  return result;
}

Falls die Rückgabegröße bekannt ist (zum Beispiel auch jedesmal 8 Bytes) könnte man mit reserve noch etwas Speed rausholen...