views:

388

answers:

2

I need a way to create a string of n chars. In this case ascii value zero.

I know I can do it by calling the constructor:

string sTemp(125000, 'a');

but I would like to reuse sTemp in many places and fill it with different lengths.

I am calling a library that takes a string pointer and length as an argument and fills the string with bytes. (I know that technically string is not contiguous, but for all intents and purposes it is, and will likly become the standard soon). I do NOT want to use a vector.

is there some clever way to call the constructor again after the string has been created?

+6  A: 

The string class provides the method assign to assign a given string a new value. The signatures are

1. string& assign ( const string& str );
2. string& assign ( const string& str, size_t pos, size_t n );
3. string& assign ( const char* s, size_t n );
4. string& assign ( const char* s );
5. string& assign ( size_t n, char c );
6. template <class InputIterator> 
     string& assign ( InputIterator first, InputIterator last );

Citing source: cplusplus.com (I recommend this website because it gives you a very elaborated reference of the C++ standard libraries.)

I think you're looking for something like the fifth one of these functions: n specifies the desired length of your string and c the character filled into this string. For example if you write

sTemp.assign(10, 'b');

your string will be solely filled with 10 b's.

I originally suggested to use the STL Algorithm std::fill but thus your string length stays unchanged. The method string::resize provides a way to change the string's size and fills the appended characters with a given value -- but only the appended ones are set. Finally string::assign stays the best approach!

phlipsy
Why down voting? Please leave at least a comment with the reason. Only this way one can learn!
phlipsy
I didn't downvote, but I dont want another #include if possible
Mike Trader
As you noticed fill is not good because it does not allow to change the size of the string. resize uses the initial character only to initialize new characters in the string (after resizing). Thous original string remains unmodified. Those are not consistent with desired effect of "call the constructor again". The proper function is assign.
Adam Badura
@Adam Badura: Yeah my first answer was quite a shoot from the hip. And Mike Trader is right when he commented he don't want to add a new header file if it isn't necessary.
phlipsy
I think you could remove the fill suggestion. IMO, assign is there precisely for that, and even beats the resize function (which will not do the right thing, if the string didn't happen to be empty).
UncleBens
@UncleBens: Originally I thought keeping my first suggestion is important because it doesn't obfuscate that my first thought wasn't the best solution too. But to underline my final solution I should turn my answer upside down.
phlipsy
+2  A: 

Try to use:

sTemp.resize(newLength, 'a');

References:

void __CLR_OR_THIS_CALL resize(size_type _Newsize)
 { // determine new length, padding with null elements as needed
 resize(_Newsize, _Elem());
 }

void __CLR_OR_THIS_CALL resize(size_type _Newsize, _Elem _Ch)
 { // determine new length, padding with _Ch elements as needed
 if (_Newsize <= _Mysize)
  erase(_Newsize);
 else
  append(_Newsize - _Mysize, _Ch);
 }
Gal Goldman
Saying "it's the following" is misleading. That's one implementation.
GMan
You are right, I rephrased.
Gal Goldman
Also, that's the wrong resize function :)
GMan
10x, wrong CTRL-V...
Gal Goldman
perfect. I guess I just missed that. thx
Mike Trader
But what happens if he wants to fill the old part of the resized string with the same constant value?
phlipsy
resize uses the initial character only to initialize new characters in the string (after resizing). Thous original string remains unmodified. This is not consistent with desired effect of "call the constructor again". The proper function is assign.
Adam Badura
Also "References" part seems to be pointless. It does not say much as it is not text and it uses other functions which are not presented in the "References" part. I don't see any use of copy-paste of some STD library implementation code. The comments present in the code ar much more useful and alone would take much less space (and reading!).
Adam Badura
@Adam, the references' purpose was to show the existing signatures so that Mike here could choose which overload to use...
Gal Goldman
@Mike - Sure...
Gal Goldman
#Gal Goldman Actually you didn't give just signatures. You gave entire definition with compiler specific macros (__CLR_OR_THIS_CALL).
Adam Badura