Videos
Can I use format specifiers for string manipulation in C?
How do you format strings in C using the printf function?
How do you use snprintf for safe string formatting in C?
Use sprintf. (This is NOT safe, but OP asked for an ANSI C answer. See the comments for a safe version.)
int sprintf ( char * str, const char * format, ... );
Write formatted data to string Composes a string with the same text that would be printed if format was used on printf, but instead of being printed, the content is stored as a C string in the buffer pointed by str.
The size of the buffer should be large enough to contain the entire resulting string (see snprintf for a safer version).
A terminating null character is automatically appended after the content.
After the format parameter, the function expects at least as many additional arguments as needed for format.
Parameters:
str
Pointer to a buffer where the resulting C-string is stored. The buffer should be large enough to contain the resulting string.
format
C string that contains a format string that follows the same specifications as format in printf (see printf for details).
... (additional arguments)
Depending on the format string, the function may expect a sequence of additional arguments, each containing a value to be used to replace a format specifier in the format string (or a pointer to a storage location, for n). There should be at least as many of these arguments as the number of values specified in the format specifiers. Additional arguments are ignored by the function.
Example:
// Allocates storage
char *hello_world = (char*)malloc(13 * sizeof(char));
// Prints "Hello world!" on hello_world
sprintf(hello_world, "%s %s!", "Hello", "world");
If you have a POSIX-2008 compliant system (any modern Linux), you can use the safe and convenient asprintf() function: It will malloc() enough memory for you, you don't need to worry about the maximum string size. Use it like this:
char* string;
if(0 > asprintf(&string, "Formatting a number: %d\n", 42)) return error;
log_out(string);
free(string);
This is the minimum effort you can get to construct the string in a secure fashion. The sprintf() code you gave in the question is deeply flawed:
There is no allocated memory behind the pointer. You are writing the string to a random location in memory!
Even if you had written
char s[42];you would be in deep trouble, because you can't know what number to put into the brackets.
Even if you had used the "safe" variant
snprintf(), you would still run the danger that your strings gets truncated. When writing to a log file, that is a relatively minor concern, but it has the potential to cut off precisely the information that would have been useful. Also, it'll cut off the trailing endline character, gluing the next log line to the end of your unsuccessfully written line.If you try to use a combination of
malloc()andsnprintf()to produce correct behavior in all cases, you end up with roughly twice as much code than I have given forasprintf(), and basically reprogram the functionality ofasprintf().
If you are looking at providing a wrapper of log_out() that can take a printf() style parameter list itself, you can use the variant vasprintf() which takes a va_list as an argument. Here is a perfectly safe implementation of such a wrapper:
//Tell gcc that we are defining a printf-style function so that it can do type checking.
//Obviously, this should go into a header.
void log_out_wrapper(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
void log_out_wrapper(const char *format, ...) {
char* string;
va_list args;
va_start(args, format);
if(0 > vasprintf(&string, format, args)) string = NULL; //this is for logging, so failed allocation is not fatal
va_end(args);
if(string) {
log_out(string);
free(string);
} else {
log_out("Error while logging a message: Memory allocation failed.\n");
}
}
So I'm switching from python to c (Yeah, static typing is hell for me right now lol).I'm creating a command line program that can interact with a csv database. On of the commands is: "./memo -i somefile" which will init a new .csv file. I want to implement a way so that "somefile" automatically turns into somefile.csv.This is my code:
```int init_func(char**i){FILE *fp;char s;fp = fopen(i,"r");if (i != NULL){printf("Are you sure you want to overwrite this file?\n");scanf(">>>%s",&s);
if(s=='y'){char*file[] = ("%s.csv",i); //This doesn't seem right.fp = fopen(file,"w");}else if(s=='n'){exit(1);}}fclose(fp);return 0;} ```
Edit: I have no idea how to use the backticks.
Hello, I am currently learning C and I was wondering what the point of format specifiers are. I understand what they do, but what is the point? If you declare a variable to be a float, why do you also have to specify the format in the printf() function? Isn't it still a float?
Thanks!
It's used to specify, in a dynamic way, what the width of the field is:
- The width is not specified in the format string, but as an additional integer value argument preceding the argument that has to be formatted.
so "indent" specifies how much space to allocate for the string that follows it in the parameter list.
So,
printf("%*s", 5, "");
is the same as
printf("%5s", "");
It's a nice way to put some spaces in your file, avoiding a loop.
Don't use "%*s" on a buffer which is not NULL terminated (packed) thinking that it will print only "length" field.