Come recuperare n caratteri dall'array char

Question

Ho un array di caratteri in un'applicazione C che devo dividere in parti di 250 in modo da poterlo inviare a un'altra applicazione che non accetta più contemporaneamente.

Come lo farei? Piattaforma: win32.

Answer 1

Dalla documentazione MSDN:

  

La funzione strncpy copia i caratteri di conteggio iniziale di strSource su strDest e restituisce strDest. Se count è inferiore o uguale alla lunghezza di strSource, un carattere null non viene aggiunto automaticamente alla stringa copiata. Se count è maggiore della lunghezza di strSource, la stringa di destinazione viene riempita con caratteri null fino al conteggio della lunghezza. Il comportamento di strncpy non è definito se le stringhe di origine e destinazione si sovrappongono.

Nota che strncpy non controlla lo spazio di destinazione valido; che è lasciato al programmatore. Prototipo:

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

Esempio esteso:

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

Posso pensare a qualcosa del genere:

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

Se cerchi le prestazioni e ti è permesso di toccare un po 'la stringa (cioè il buffer non è const, nessun problema di sicurezza del thread ecc.), potresti momentaneamente annullare la stringa a intervalli di 250 caratteri e inviare a pezzi, direttamente dalla stringa originale:

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

La risposta di jvasaks è sostanzialmente corretta, tranne per il fatto che non ha annullato il 'blocco'. Il codice dovrebbe essere questo:

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;
    }

}

Quindi, ora il blocco è di 250 caratteri incluso il null di terminazione. strncpy annullerà l'ultimo blocco se rimangono meno di 249 caratteri.