Jak dodać linie za pomocą sprintf?

Potrzebujesz:

sprintf(Buffer,"Hello World");

sprintf(Buffer + strlen(Buffer),"Good Morning");

sprintf(Buffer + strlen(Buffer),"Good Afternoon");

i oczywiście potrzebujesz odpowiedniego bufora.

int length = 0;

length += sprintf(Buffer+length, "Hello World");

length += sprintf(Buffer+length, "Good Morning");

length += sprintf(Buffer+length, "Good Afternoon");

Oto wersja z pewną tolerancją błędów. Jest to przydatne, jeśli nie przejmujesz się tym, kiedy zdarzają się błędy, o ile możesz kontynuować swoją wesołą drogę, gdy się pojawią.

int bytes_added( int result_of_sprintf )

{

 return (result_of_sprintf > 0) ? result_of_sprintf : 0;

}int length = 0;

length += bytes_added(sprintf(Buffer+length, "Hello World"));

length += bytes_added(sprintf(Buffer+length, "Good Morning"));

length += bytes_added(sprintf(Buffer+length, "Good Afternoon"));

Ze względów bezpieczeństwa (przepełnienie bufora) polecam używanie snprintf ()

const int MAX_BUF = 1000;
char* Buffer = malloc(MAX_BUF);int length = 0;
length += snprintf(Buffer+length, MAX_BUF-length, "Hello World");
length += snprintf(Buffer+length, MAX_BUF-length, "Good Morning");
length += snprintf(Buffer+length, MAX_BUF-length, "Good Afternoon");

Opakowanie

snprintfcat ()

dla

snprintf ()

:

size_t 

snprintfcat( char* buf,

 size_t bufSize,

 char const* fmt,

 ...)

{

 size_t resu<

 va_list args;

 size_t len = strnlen( buf, bufSize); va_start( args, fmt);

 result = vsnprintf( buf + len, bufSize - len, fmt, args);

 va_end( args); return result + len;

}

Użyj wartości zwracanej

sprintf ()

Buffer += sprintf(Buffer,"Hello World");

Buffer += sprintf(Buffer,"Good Morning");

Buffer += sprintf(Buffer,"Good Afternoon");

Dlaczego miałbyś chcieć używać

sprintf

do konkatenacji ciągów, skoro istnieją metody zaprojektowane specjalnie do tego, czego potrzebujesz, takie jak

strcat

http://www.cplusplus.com/refer ... rcat/
i

strncat

http://www.cplusplus.com/refer ... ncat/
?

Czy dodajesz tylko literały ciągów? A może zamierzasz dodać różne typy danych (liczby całkowite, zmiennoprzecinkowe itp.)?
Może być łatwiej wyabstrahować to do własnej funkcji (zakłada się C99 poniżej):

#include <stdio.h>

#include <stdarg.h>

#include <string.h>int appendToStr(char *target, size_t targetSize, const char * restrict format, ...)

{

 va_list args;

 char temp[targetSize];

 int resu< va_start(args, format);

 result = vsnprintf(temp, targetSize, format, args);

 if (result != EOF)

 {

 if (strlen(temp) + strlen(target) > targetSize)

 {

 fprintf(stderr, "appendToStr: target buffer not large enough to hold additional string");

 return 0;

 }

 strcat(target, temp);

 }

 va_end(args);

 return resu<

}

Używałbyś tego w ten sposób:

char target[100] = {0};...

appendToStr(target, sizeof target, "%s %d %f\n", "This is a test", 42, 3.14159);

appendToStr(target, sizeof target, "blah blah blah");

itp.
Funkcja zwraca wartość z

vsprintf

, która w większości implementacji jest liczbą bajtów zapisanych w miejscu docelowym. Jest kilka dziur w tej implementacji, ale powinno dać ci kilka pomysłów.

Myślę, że szukasz

fmemopen (3)

:

#include <assert.h>

#include <stdio.h>int main(void)

{

 char buf[128] = { 0 };

 FILE *fp = fmemopen(buf, sizeof(buf), "w"); assert(fp); fprintf(fp, "Hello World!\n");

 fprintf(fp, "%s also work, of course.\n", "Format specifiers");

 fclose(fp); puts(buf);

 return 0;

}

Jeśli dynamiczna pamięć masowa jest bardziej odpowiednia dla twojego przypadku, możesz skorzystać z doskonałej sugestii Liama, aby użyć

open_memstream (3)

:

#include <assert.h>

#include <stdio.h>

#include <stdlib.h>int main(void)

{

 char *buf;

 size_t size;

 FILE *fp = open_memstream(&buf, &size); assert(fp); fprintf(fp, "Hello World!\n");

 fprintf(fp, "%s also work, of course.\n", "Format specifiers");

 fclose(fp); puts(buf);

 free(buf);

 return 0;

}

Uważam, że następująca metoda działa świetnie.

sprintf(Buffer,"Hello World");

sprintf(&Buffer[strlen[Buffer]],"Good Morning");

sprintf(&Buffer[strlen[Buffer]],"Good Afternoon");

Możesz użyć prostej linii pokazanej poniżej, aby dodać linie do jednego bufora:

sprintf(Buffer,"%s %s %s","Hello World","Good Morning","Good Afternoon");

Użyj strcat

http://www.cplusplus.com/reference/cstring/strcat
http://www.cplusplus.com/reference/cstring/strcat/
/

int main ()

 {

 char str[80];

 strcpy (str,"these ");

 strcat (str,"strings ");

 strcat (str,"are ");

 strcat (str,"concatenated.");

 puts (str);

 return 0;

 }

 Output:

 these strings are concatenated.

Piszę funkcję wsparcia dla dynamicznego ciągu zmiennej, aby dodać jak st. Dodatki PHP: pgt. św. ... itd.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>int str_append(char **json, const char *format, ...)

{

 char *str = NULL;

 char *old_json = NULL, *new_json = NULL; va_list arg_ptr;

 va_start(arg_ptr, format);

 vasprintf(&str, format, arg_ptr);// save old json

 asprintf(&old_json, "%s", (*json == NULL ? "" : *json));// calloc new json memory

 new_json = (char *)calloc(strlen(old_json) + strlen(str) + 1, sizeof(char)); strcat(new_json, old_json);

 strcat(new_json, str); if (*json) free(*json);

 *json = new_json; free(old_json);

 free(str); return 0;

}int main(int argc, char *argv[])

{

 char *json = NULL;/*

 str_append(&json, "name: %d, %d, %d", 1, 2, 3);

 str_append(&json, "sex: %s", "male");

 str_append(&json, "end");

 str_append(&json, "");

 str_append(&json, "{\"ret\":true}");

 */ int i;

 for (i = 0; i < 100; i++) {

 str_append(&json, "id-%d", i);

 } printf("%s\n", json); if (json) free(json); return 0;

}

Mały, kompletny przykład kodu

Korzystanie z płaskiej, zwykłej biblioteki standardowej

stdio

tylko

#include <stdio.h>

int main()

 {

 char c[1024];

 int i=0; i+=sprintf(c+i,"We " );

 i+=sprintf(c+i,"Love " );

 sprintf(c+i,"Coding"); printf("%s",c);

 }

OUTPUT:

Kochamy kodowanie

char string1[] = "test";

char string2[] = "string";

int len = sizeof(string1) + sizeof(string2);

char totalString[len];

sprintf(totalString, "%s%s",string1,string2);

Za pomocą

strcat
https://linux.die.net/man/3/strcat
(

bufor

, „

Twój nowy ciąg ... tutaj

”) jako opcja.

Co powiesz na:

char s[100] = "";sprintf(s, "%s%s", s, "s1");sprintf(s, "%s%s", s, "s2");sprintf(s, "%s%s", s, "s3");printf("%s", s);

Ale rozważ możliwe przepływy buforowe!