33

I wan to use std::string simply to create a dynamic buffer and than iterate through it using an index. Is resize() the only function to actually allocate the buffer?

I tried reserve() but when I try to access the string via index it asserts. Also when the string's default capacity seems to be 15 bytes (in my case) but if I still can't access it as my_string[1].

So the capacity of the string is not the actual buffer? Also reserve() also does't allocate the actual buffer?

string my_string;

// I want my string to have 20 bytes long buffer
my_string.reserve( 20 );

int i = 0;

for ( parsing_something_else_loop )
{
    char ch = <business_logic>;

    // store the character in 
    my_string[i++] = ch; // this crashes
}

If I do resize() instead of reserve() than it works fine. How is it that the string has the capacity but can't really access it with []? Isn't that the point to reserve() size so you can access it?

Add-on In response to the answers, I would like to ask stl folks, Why would anybody use reserve() when resize() does exactly the same and it also initialize the string? I have to say I don't appreciate the performance argument in this case that much. All that resize() does additional to what reserve() does is that it merely initialize the buffer which we know is always nice to do anyways. Can we vote reserve() off the island?

Improve this question
2
  • 2
    Would a byte vector be more appropriate Commented Mar 1, 2012 at 18:19
  • std::vector seem also a possible solution for your requirements. Would a answer with std::vector also be an acceptable answer? Commented Mar 1, 2012 at 18:20

6 Answers 6

Reset to default
54

Isn't that the point to reserve() size so you can access it?

No, that's the point of resize().

reserve() only gives to enough room so that future call that leads to increase of the size (e.g. calling push_back()) will be more efficient.

From your use case it looks like you should use .push_back() instead.

my_string.reserve( 20 );

for ( parsing_something_else_loop )
{
    char ch = <business_logic>;
    my_string.push_back(ch);
}

How is it that the string has the capacity but can't really access it with []?

Calling .reserve() is like blowing up mountains to give you some free land. The amount of free land is the .capacity(). The land is there but that doesn't mean you can live there. You have to build houses in order to move in. The number of houses is the .size() (= .length()).

Suppose you are building a city, but after building the 50th you found that there is not enough land, so you need to found another place large enough to fit the 51st house, and then migrate the whole population there. This is extremely inefficient. If you knew you need to build 1000 houses up-front, then you can call

my_string.reserve(1000);

to get enough land to build 1000 houses, and then you call

my_string.push_back(ch);

to construct the house with the assignment of ch to this location. The capacity is 1000, but the size is still 1. You may not say

my_string[16] = 'c';

because the house #16 does not exist yet. You may call

my_string.resize(20);

to get houses #0 ~ #19 built in one go, which is why 

my_string[i++] = ch;

works fine (as long as 0 ≤ i ≤ 19).

See also http://en.wikipedia.org/wiki/Dynamic_array.

For your add-on question,

.resize() cannot completely replace .reserve(), because (1) you don't always need to use up all allocated spaces, and (2) default construction + copy assignment is a two-step process, which could take more time than constructing directly (esp. for large objects), i.e.

#include <vector>
#include <unistd.h>

struct SlowObject
{
    SlowObject() { sleep(1); }
    SlowObject(const SlowObject& other) { sleep(1); }
    SlowObject& operator=(const SlowObject& other) { sleep(1); return *this; }
};

int main()
{
    std::vector<SlowObject> my_vector;

    my_vector.resize(3);
    for (int i = 0; i < 3; ++ i)
        my_vector[i] = SlowObject();

    return 0;
}

Will waste you at least 9 seconds to run, while

int main()
{
    std::vector<SlowObject> my_vector;

    my_vector.reserve(3);
    for (int i = 0; i < 3; ++ i)
        my_vector.push_back(SlowObject());

    return 0;
}

wastes only 6 seconds.

std::string only copies std::vector's interface here.

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

Think of it this way: the string still has a size, which has not been changed by reserve(); however, you have allocated a contiguous chunk of memory so that the string may be resize()'d without incurring a copying of the whole string. It will still, however, check that your index is in bounds with the (logical) size of the string. Reserve is an optimization when you have some ahead-of-time knowledge about how big the string gets - it's like the c idiom of char[1000] - you have 1000 bytes available even though the string may only be "Hello, world"
So lets say I start out with your example with 'my_string.resize(1000)', what's the performance hit really? I will argue it is better because it reduce one line in the code (the resize() later on) so I have less code to manage.
@KennyTM your add-on example is about vector but I only want to restrict to string class. In any way OOP is all about objects and object initialization is fundamental part of it. Are we going to disregard OOP principals to achieve marginally better efficiency?
@zadane: You could have std::basic_string<SlowObject>. OOP is about encapsulation, inheritance and polymorphism, but object initialization, and std::string has nothing to do with OOP.
@zadane: Besides, because of backward compatibility, it is almost impossible to remove any feature from C++, even if it is illogical now. (trigraphs, vector<bool>, strstream, etc.)
|
7

No -- the point of reserve is to prevent re-allocation. resize sets the usable size, reserve does not -- it just sets an amount of space that's reserved, but not yet directly usable.

Here's one example -- we're going to create a 1000-character random string:

static const int size = 1000;
std::string x;
x.reserve(size);
for (int i=0; i<size; i++)
   x.push_back((char)rand());

reserve is primarily an optimization tool though -- most code that works with reserve should also work (just, possibly, a little more slowly) without calling reserve. The one exception to that is that reserve can ensure that iterators remain valid, when they wouldn't without the call to reserve.

Improve this answer

Comments

4

The capacity is the length of the actual buffer, but that buffer is private to the string; in other words, it is not yours to access. The std::string of the standard library may allocate more memory than is required to storing the actual characters of the string. The capacity is the total allocated length. However, accessing characters outside s.begin() and s.end() is still illegal.

You call reserve in cases when you anticipate resizing of the string to avoid unnecessary re-allocations. For example, if you are planning to concatenate ten 20-character strings in a loop, it may make sense to reserve 201 characters (an extra one is for the zero terminator) for your string, rather than expanding it several times from its default size.

Improve this answer

Comments

2

reserve(n) indeed allocates enough storage to hold at least n elements, but it doesn't actually fill the container with any elements. The string is still empty (has size 0), but you are guaranteed, that you can add (e.g. through push_back or insert) at least n elements before the string's internal buffer needs to be reallocated, whereas resize(n) really resizes the string to contain n elements (and deletes or adds new elements if neccessary).

So reserve is actually a mere optimization facility, when you know you are adding a bunch of elements to the container (e.g. in a push_back loop) and don't want it to reallocate the storage too often, which incurs memory allocation and copying costs. But it doesn't change the outside/client view of the string. It still stays empty (or keeps its current element count).

Likewise capacity returns the number of elements the string can hold until it needs to reallocate its internal storage, whereas size (and for string also length) returns the actual number of elements in the string.

Improve this answer

Comments

1

Just because reserve allocates additional space does not mean it is legitimate for you to access it.

In your example, either use resize, or rewrite it to something like this:

string my_string;

// I want my string to have 20 bytes long buffer
my_string.reserve( 20 );

int i = 0;

for ( parsing_something_else_loop )
{
    char ch = <business_logic>;

    // store the character in 
    my_string += ch;
}
Improve this answer

Comments

1

std::vector instead of std::string might also be a solution - if there are no requirements against it.

vector<char> v; // empty vector
vector<char> v(10); // vector with space for 10 elements, here char's

Your example:

vector<char> my_string(20);

int i=0;

for ( parsing_something_else_loop )
{
    char ch = <business_logic>;
    my_string[i++] = ch;
}
Improve this answer

3 Comments

This doesn't really answer the OP's actual question, but merely transforms it into a completely indentical problem.
I asked in a comment below the question if std::vector might be an option, saw no yes or no and offered an alternative solution, even marked is, as a alternative ("std::vector instead of std::string might also be a solution"). I don't see the harm that you see.
I don't see any harm, too, as long as comments stay comments and answers stay answers. But your "answer" is just a comment, though a good one, but still a comment and not an answer to any of his questions.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.