Printable View
I have a string that I created and passed as a parameter to my output function. I need to add this string to an existing string as an out.open() parameter.
This is what I tried to do:
It's obviously not working but if anyone could help me that would be great. Thanks!Code:out.open("page"+pageNo+".html");
open requires a C string, not a std::string. So create a temporary string object, set it to "page"+pageNo+".html", and then in the open call you would use tempstring.c_str().
I am guessing pageNo is an int or something.
Google std::stringstream.
yeah I used sstream to convert the int to a string.Quote:
Originally Posted by cyberfish
Just allocate some memory and use sprintf.
sprintf(szBuffer, "page %d .html", pageNo);
out.open(szBuffer);
No need to go C way here.
Exploit the overloaded operators of std::string.
Code:out.open((std::string("page")+pageNo+".html").c_str());
Doesn't he need?Code:out.open((std::string("page")+pageNo+".html").c_str());
hmm. Right :).
Thanks for the correction. Edited my post.
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);
You have one more space at char page[] = "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...Quote:
Originally Posted by execute
--
Mats
Well if you wanna make it all complicated, and take into account: "Well what if they need it in KOREAN!" or that sort of thing, then obviously, you would make your own string classes and functions.
I was just giving the simplest form of the task (the very very simplest method).
Yes, tedious to type, but it would be worth it in certain situations! I dunno, like an embedded system that only has 50 bytes of memory!
Are we writing for those systems here, though?Quote:
Originally Posted by execute
Premature optimization is a bad thing, as it usually complicates and obfuscates code.
You could change it to:
... and it would be less tedious to type but still not particularly robust.Code:int pageNo = 1;
char page[] = "pageZ.html";
page[4] = '0'+pageNo;
I think that comment was firmly tongue in cheek :)Quote:
Originally Posted by matsp
This is the wrong thing:
this is the correct thing:Code:out.open("page"+pageNo+".html");
They are not that different. So there is nothing more simple than the above as the correct answer.Code:out.open((std::string("page")+pageNo+".html").c_str());
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):
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*.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);
...
Well, it might work for this situation. But if you want it to be both valid in case the filename would be "page #.html" (with space) as well, and faster, you could use:Quote:
Originally Posted by R.Stiltskin
Code:ss << "page" << pageNo << ".html";
out.open(ss.str().c_str());
I got it working. Thanks guys!