Thread: Add strings together

No need to go C way here.

Exploit the overloaded operators of std::string.

Code:

out.open((std::string("page")+pageNo+".html").c_str());

Here is the more Efficient, Lightweight way of doing what you want to do:
Note: Only works with 1 digit, you'll need a function (like iota) if you want more digits etc.

Code:

int pageNo = 1;
char page[] = "page       ";
page[4] = '0'+pageNo;
page[5] = '.';
page[6] = 'h';
page[7] = 't';
page[8] = 'm';
page[9] = 'l';

// now page = page1.html
out.open(page);

Originally Posted by execute

Here is the more Efficient, Lightweight way of doing what you want to do:
Note: Only works with 1 digit, you'll need a function (like iota) if you want more digits etc.

Code:

int pageNo = 1;
char page[] = "page       ";
page[4] = '0'+pageNo;
page[5] = '.';
page[6] = 'h';
page[7] = 't';
page[8] = 'm';
page[9] = 'l';

// now page = page1.html
out.open(page);

But also very error prone and quite tedious to type - yes, it's only the once, but if you have to do it slightly differentely (e.g. the "page" changes to some other word in a foreign language or some such), you have to count the characters, and get everything right. How muhc more work is it to use a more automatic method - considering that this probably ends up with either reading or writing some sort of html content from/to a file...

--
Mats

This is the wrong thing:

Code:

out.open("page"+pageNo+".html");

this is the correct thing:

Code:

out.open((std::string("page")+pageNo+".html").c_str());

They are not that different. So there is nothing more simple than the above as the correct answer.

About efficiency I don't think there is a huge difference.
I would expect them to have the same speed more or less. Of course you give the total size so it allocates only once. You could call string::reserve for that to be fair.
But in any case you allocate space, initialize it, and write again on that memory.
The above "correct" method allocates space, initializes it, allocates space, initializes, allocates space initializes it.
Since the string is not really big there won't be probably any need to copy data for the std::string. So it is 3 allocations vs 1 allocation and rewriting a memory space (page[4]).
Now, do this with reserve (which is fair). Now you allocate space, initialize on part, initialize other part, initialize other part.
So it is 3 allocations+initialization and 1 rewrite vs 3 allocations+initialization. So the std::string method might actually be faster.

Of course the std::string will have some function calls overhead. But those are not that big of a time waste. And they are totally worth it.

But the point is that you might NOT know the size. Especially considering that pageNo WILL change. It might go over 9. So you would need one more space.

Assuming the OP isn't optimizing for some tiny embedded system, and is already using sstream rather than implementing his own itoa() to convert the integer pageNo to a string, why not simply stick with stringstream:

Code:

...
    std::stringstream ss;               // he already has the equivalent of this in his code
    int pageNo = 31;                    // he already has the equivalent of this in his code
    ss << "page" << pageNo << ".html";  // he already has 'ss << pageNo;' in his code
    std::string s;
    ss >> s;
    out.open(s.c_str());
...

or, if you object to the overhead of std::string (and he's not already using it someplace anyway):

Code:

...
    std::stringstream ss;               // he already has the equivalent of this in his code
    int pageNo = 31;                    // he already has the equivalent of this in his code
    ss << "page" << pageNo << ".html";  // he already has 'ss << pageNo;' in his code
    char cs[5];
    const char* cp = cs;
    ss >> cs;
    out.open(cp);
...

Now the only added overhead is a 5-byte char array (assuming his page numbers are no more than 4 digits) and a const char*.