Printing like Perl in C++ - c++

Question

Can I do something like the following Perl code in C++ ?
i.e Replicate $string n times ?
printf ("%s\n",$string x 4);

Answer 1

While C++ doesn't have an operator x, C++ is a flexible enough language that you can write a named operator x whose job it is to multiply strings:
#include <string>
namespace strop {
struct x_op {} x;
struct x_lhs { std::string s; };
x_lhs operator*( std::string s, x_op ) {
return {std::move(s)};
}
std::string operator*( x_lhs&& lhs, std::size_t rhs ) {
std::string retval;
for( std::size_t i = 0; i < rhs; ++i ) {
retval += lhs.s;
}
return retval;
}
}
use:
#include <iostream>
using strop::x;
int main () {
std::string foo = "foo";
std::cout << (foo *x* 5) << "\n"; // if you prefer std::cout
printf("%s", (foo *x* 5).c_str()); // if you prefer printf
}
The above uses some trivial C++11 features, but not essentially.
C++03 version (it is less efficient):
#include <string>
namespace strop {
struct x_op {} x;
struct x_lhs { std::string s; x_lhs(std::string s_):s(s_) {} };
x_lhs operator*( std::string s, x_op ) {
return x_lhs(s);
}
std::string operator*( x_lhs lhs, std::size_t rhs ) {
std::string retval;
for( std::size_t i = 0; i < rhs; ++i ) {
retval += lhs.s;
}
return retval;
}
}
amusingly, this works with string literals:
std::cout << "bar" *x* 3 << "\n";
because they are turned into std::strings implicitly. If you are using printf, you still need to wrap it in ().c_str(), or you are risking undefined behavior (even if you never mention std::string).
You could instead overload some other non-named operator, but overloading operators when you own neither type in the overload is pretty rude, and can lead to complications.
The above technique uses the placeholder types of x_op and x_lhs to ensure that the overloaded operator will only come into effect when we are interacting with our named operator.
The choice of * to wrap our named operator x is because the operation is multiplication-like.
Bonus: Insane version of operator*, which uses bit values of the rhs to reduce the amount of string wrangling:
std::string operator*( x_lhs lhs, std::size_t rhs ) {
std::string retval;
auto done = [rhs]( std::size_t n ) {
return !(i < (sizeof(rhs)*8) && !(rhs &~std::size_t((1<<i)-1)));
};
for( int i = 0; true; ++i) {
if (!done(i+1)) {
if (rhs & (1 << i))
retval += lhs;
lhs += lhs;
continue;
} else {
// high bit must be set, or we'd be done before, unless rhs was 0:
if (rhs != 0)
retval += std::move(lhs);
break;
}
}
return retval;
}
which has not been tested, but amuses me.

Answer 2

Preface: overloading operators is a nuanced practice. If you're not careful, it can lead to code which is difficult to read and maintain. That said ...
You could try overloading operator*(), but in order to make that work you'll need to use string objects and not bare c-strings. The reason is that C++ does not allow you overload operators which only reference built-in types. The std::string class is not built in to the language.
For example, the following function will do what you intend with std::string objects. Note that the return type is a const char* to be compatible with printf().
const char* operator*(const std::string& input, size_t repeat)
{
std::string output;
for (size_t ii=0; ii<repeat; ++ii)
output += input;
return output.c_str();
}
With that function you can then use the syntax you prefer if the strings are stored in std::string objects:
int main(int argc, char** argv)
{
std::string input = argv[1];
printf("%s\n", input*3); // works
printf("%s\n", std::string(argv[1])*3); // works
//printf("%s\n", argv[1]*3); // compile error
}
A more natural C++ way of doing it would be to use <iostream>, which does not require you to mix char* and std::string types in the overloaded operator.
std::string operator*(const std::string& input, size_t repeat)
{
std::string output;
for (size_t ii=0; ii<repeat; ++ii)
output += input;
return output;
}
int main(int argc, char** argv)
{
std::cout << std::string(argv[1])*3 << std::endl;
}

Answer 3

No, not directly. You need to do it yourself:
for (size_t i = 0; i < 4; ++i)
printf ("%s", astring);
printf ("\n");

Answer 4

As impressive as #Yakk's overloading is, why not just define a simple function?
std::string repeat(const std::string& s, int times) {
std::string res;
res.reserve(s.size() * times);
for (int i = 0; i < times; ++i)
res += s;
return s;
}
Then you can do
std::cout << repeat("foo", 4) << std::endl;
Prints foofoofoofoo.

Answer 5

You can just use a for loop:
for(int i=0;i<n;i++)
cout<<string;