Wie man n Zeichen von char-Array abrufen

Question

Ich habe einen char-Array in einer C-Anwendung, die ich in Teile von 250 geteilt habe, so dass ich sie zusammen in einer anderen Anwendung senden kann, der nicht mehr auf einmal akzeptiert.

Wie würde ich das tun? Plattform: win32.

Answer 1

Aus der MSDN-Dokumentation:

  

Die Strncpy Funktion kopiert die anfängliche Anzahl Zeichen von strSource zu strDest und gibt strDest. Bei weniger als oder gleich der Länge von strSource, ein Null-Zeichen wird nicht automatisch auf die kopierte Zeichenfolge angehängt. Wenn count größer als die Länge von strSource ist, wird der Ziel-String mit Null-Zeichen aufgefüllt bis zu einer Länge Zahl. Das Verhalten von strncpy ist nicht definiert, wenn die Quell- und Ziel Strings überlappen.

, dass strncpy Hinweis nicht für gültigen Zielraum überprüfen; das heißt mit dem Programmierer überlassen. Vorbild:

char *strncpy( char *strDest, const char *strSource, size_t count );

Erweitertes Beispiel:

void send250(char *inMsg, int msgLen)
{
    char block[250];
    while (msgLen > 0)
    {
         int len = (msgLen>250) ? 250 : msgLen;
         strncpy(block, inMsg, 250);

         // send block to other entity

         msgLen -= len;
         inMsg  += len;
    }
}

Answer 2

Ich kann entlang der Linien des folgend etwas einfallen lassen:

char *somehugearray;
char chunk[251] ={0};
int k;
int l;
for(l=0;;){
  for(k=0; k<250 && somehugearray[l]!=0; k++){
    chunk[k] = somehugearray[l];
    l++;
  }
  chunk[k] = '\0';
  dohandoff(chunk);
}

Answer 3

Wenn Sie für die Leistung streben und Sie die Zeichenfolge ein wenig zu berühren erlaubt (dh der Puffer nicht const ist, keine Gewinde Sicherheitsfragen etc.), könnte man für einen Moment die Zeichenfolge in Abständen von 250 Zeichen Null beenden und senden es in Stücken, direkt von der ursprünglichen Zeichenfolge:

char *str_end = str + strlen(str);
char *chunk_start = str;

while (true) {
    char *chunk_end = chunk_start + 250;

    if (chunk_end >= str_end) {
        transmit(chunk_start);
        break;
    }

    char hijacked = *chunk_end;
    *chunk_end = '\0';
    transmit(chunk_start);
    *chunk_end = hijacked;

    chunk_start = chunk_end;
}

Answer 4

jvasaks Antwort ist grundsätzlich richtig, mit der Ausnahme, dass er beendet nicht null ist ‚Block‘. Der Code sollte sein:

void send250(char *inMsg, int msgLen)
{
    char block[250];
    while (msgLen > 0)
    {
         int len = (msgLen>249) ? 249 : msgLen;
         strncpy(block, inMsg, 249);
         block[249] = 0;

         // send block to other entity

         msgLen -= len;
         inMsg  += len;
    }

}

So, jetzt ist der Block 250 Zeichen einschließlich der abschließenden Null. Strncpy wird den letzten Block null beenden, wenn es weniger als 249 verbleibenden Zeichen.