Thread: (x)printf() - very confused

Greetings,

The explanation of the difference is actually quite short.

» int printf(const char *format[ , argument , ...]);
Prints to standard output (stdout) a sequence of arguments formatted as the format argument specifies.

· format
String that contains the text to be printed.
Optionally it can contain format tags that are substituted by the values specified in subsequent argument(s) and formatted as requested.
· argument(s)
Optional parameter(s) that contain the data to be inserted instead of % tags specified in format parameter.


» int sprintf(char *buffer, const char *format[ , argument , ...]);
Writes a sequence of arguments to the given buffer formatted as the format argument specifies.

· buffer
Buffer where to store the resulting formatted string.
· format
Same as above.
· argument(s)
Same as above.


I don't know much about snprintf() though I believe it is similar to sprintf(), but allows you to choose the buffer size. I believe it is just like the difference between strcpy() and strncpy().

Edit:

Examples

Code:

#include <stdio.h>

int main() {
	char buf[64];
	const char ch[] = "My string";
	const char str[] = "My other string";

	printf(ch);
	printf(" - %s", str);

	sprintf(buf, "(%s) [%s]\n", ch, str);
	printf(buf);

	return 0;
}

For more information, I do believe this page will be of some clarification: snprintf() man pages

Hope this helps,
- Stack Overflow

I would suggest snprintf().

snprintf() will write at most size-1 of the characters printed into the output string (the size'th character then gets the terminating `\0'); if the return value is greater than or equal to the size argument, the string was too short and some of the printed characters were discarded.

int snprintf(char *str, size_t size, const char *format, ...);

I edited my post with further information, but I'll post again. Here are the snprintf() man pages

snprintf() isn't used to output information. snprintf() is to create a formatted string. printf() is used to output information. It's really very simple once you understand that the format string that you pass to all 3 functions behaves exactly the same in all 3 functions. The only difference is printf() writes the formatted string to stdout and sprintf and snprintf() store the formatted string in a buffer. The only difference between sprintf() and snprintf() is that you can be sure to avoid buffer overflows with snprintf().

Say you have this:

Code:

#include <stdio.h>

int main(void)
{
  char buf[20];

  int num = 5;

  sprintf(buf, "%d", num);
  return 0;
}

Now...if converting num to a string took more than 19 characters then you'd have a buffer overflow problem. You can replace the sprintf() call with snprintf(buf, sizeof(buf), "%d", num);...this makes it so even if convering num took more than 19 characters, it would still only try to store 19 characters in buf...the rest of the numbers would be truncated.

Think of printf() as the same as:

Code:

sprintf(buf, "%d", num);
puts(buf);

That's basically all that printf() is only it doesn't suffer from buffer overflows

yeah, the main difference between all the different printf functions is where they print to and what their argument list is (variable length, or va_list). The unsafeness comes from the output mode usually then: if a printf () string is too long, it just prints more to the screen... if an fprintf () string is too long (out of disk space or wahtever), it just fails. if an sprintf () string is longer than the buffer its being written into, it has no way to know this, so it overwrites forbidden memory. the best you could do would be compare sprintf()s return after the fact, but by then its too late... but since you tell snprintf the max size of your buffer, it won't overflow it.

reminds me of a noob thing i did once forgetting the existance of snprintf... sprintf() to a (hopefully large enough) buffer, then made the program die with error ("it wasnt big enough") if sprintf ended up writing more.. but of course this is insufficient for both stability and security, as a cleverly crafted call to sprintf() might have already overwritten the next instruction before you even get there.