I'd like to do something like printf("?", count, char) to repeat a character count times.
What is the right format-string to accomplish this?
EDIT: Yes, it is obvious that I could call printf() in a loop, but that is just what I wanted to avoid.
You can use the following technique:
printf("%.*s", 5, "=================");
This will print "====="
It works for me on Visual Studio, no reason it shouldn't work on all C compilers.
[Edit]
Note that this format specifier will print a left substring of the input, so the number you use has to be <= the width of the string
Short answer - yes, long answer: not how you want it.
You can use the %* form of printf, which accepts a variable width. And, if you use '0' as your value to print, combined with the right-aligned text that's zero padded on the left..
printf("%0*d\n", 20, 0);
produces:
00000000000000000000
With my tongue firmly planted in my cheek, I offer up this little horror-show snippet of code.
Some times you just gotta do things badly to remember why you try so hard the rest of the time.
#include <stdio.h>
int width = 20;
char buf[4096];
void subst(char *s, char from, char to) {
while (*s == from)
*s++ = to;
}
int main() {
sprintf(buf, "%0*d", width, 0);
subst(buf, '0', '-');
printf("%s\n", buf);
return 0;
}
4096. I suppose you could malloc the buffer. –
Furman char repeatedly. There is no reason to create an array full of '0' characters and then replace them with the desired character, instead of just filling it with the desired character in the first place (well, no reason except to somehow use a format string in the process, which is the point here.) –
Extravagant If you limit yourself to repeating either a 0 or a space you can do:
For spaces:
printf("%*s", count, "");
For zeros:
printf("%0*d", count, 0);
" " instead of "" ? –
Pondweed In c++ you could use std::string to get repeated character
printf("%s",std::string(count,char).c_str());
For example:
printf("%s",std::string(5,'a').c_str());
output:
aaaaa
std::string is already out of scope by the time you're c_str()-ing it. (For posterity. I realise it's a 9 years old answer.) –
Chappy printf() call (since it is part of the same full-expression) –
Cablegram There is no such thing. You'll have to either write a loop using printf or puts, or write a function that copies the string count times into a new string.
puts because it adds a newline. Nor should you use fputs or printf because they are overkill when you are only printing a char. The proper choice is to loop over putchar. –
Saxen printf doesn't do that -- and printf is overkill for printing a single character.
char c = '*';
int count = 42;
for (i = 0; i < count; i ++) {
putchar(c);
}
Don't worry about this being inefficient; putchar() buffers its output, so it won't perform a physical output operation for each character unless it needs to.
printf, the format string is "%c". But you don't need to use printf, and in that case you don't need a format string at all. (There simply is no printf format string that will print a character multiple times, but there are other and better ways to accomplish the task.) –
Furman If you have a compiler that supports the alloca() function, then this is possible solution (quite ugly though):
printf("%s", (char*)memset(memset(alloca(10), '\0', 10), 'x', 9));
It basically allocates 10 bytes on the stack which are filled with '\0' and then the first 9 bytes are filled with 'x'.
If you have a C99 compiler, then this might be a neater solution:
for (int i = 0; i < 10; i++, printf("%c", 'x'));
putchar('x') instead of printf("%c", 'x'). –
Lacrosse #include <stdio.h>
#include <string.h>
void repeat_char(unsigned int count, char ch) {
char buffer[count + 1];
memset(buffer, ch, count);
buffer[count] = '\0';
printf("%s", buffer)
}
you can make a function that do this job and use it
#include <stdio.h>
void repeat (char input , int count )
{
for (int i=0; i != count; i++ )
{
printf("%c", input);
}
}
int main()
{
repeat ('#', 5);
return 0;
}
This will output
#####
i < count. Otherwise a negative input for count might result in a lot of unwanted prints. –
Sisson char buffer[41];
memset(buffer, '-', 40); // initialize all with the '-' character<br /><br />
buffer[40] = 0; // put a NULL at the end<br />
printf("%s\n", buffer); // show 40 dashes<br />
printf("%.*s\n",n,(char *) memset(buffer,c,n));
n <= sizeof(buffer) [ maybe also n < 2^16]
However the optimizer may change it to puts(buffer) and then the lack of EoS will .....
And the assumption is that memset is an assembler instruction (but still a loop be it on chip).
Strictly seen there is no solution given you precondition 'No loop'.
For best performance you could use memset then send that string directly to printf:
char buffer[40];
memset(buffer, '-', 39); // Set 39 characters
buffer[39] = 0; // Tag the end of the string
printf(buffer); // Print it
For instance, this method could be used to produce a rectangle of a given width and height:
#include <stdio.h>
int main() {
int width = 40; // External width
int height = 7; // External height
char buffer[width + 2];
memset(buffer, '-', width); // Set the dashes
buffer[width] = '\n'; // Add carriage return
buffer[width + 1] = 0; // Tag the end of string
printf(buffer);
char buffer2[width + 2];
memset(buffer2 + 1, ' ', width - 2);
buffer2[0] = '|';
buffer2[width - 1] = '|';
buffer2[width] = '\n';
buffer2[width + 1] = 0;
int l = height - 2;
while (l-- > 0)
printf(buffer2);
printf(buffer);
return 0;
}
Output:
----------------------------------------
| |
| |
| |
| |
| |
----------------------------------------
i think doing some like this.
void printchar(char c, int n){
int i;
for(i=0;i<n;i++)
print("%c",c);
}
printchar("*",10);
© 2022 - 2024 — McMap. All rights reserved.
printfformat that does what you want), but your comments leave me unsure what you're asking. You talk about a format string and arguments being passed into your function. What function are you asking about? It seems there are things you're not telling us. – Furmanprintfor similar function, you could add this functionality, but you'd still have to do a loop, which you can still do, as the inputs would be variables, which is perfectly valid! – Turgent