Can C++ automatic variables vary in size?

Question

In the following C++ program:

#include <string>
using namespace std;

int main()
{
    string s = "small";
    s = "bigger";
}

is it more correct to say that the variable s has a fixed size or that the variable s varies in size?

Answer 1

Neither, exactly. The variable s is referring to a string object.

#include <string>
using namespace std;

int main()
{
    string s = "small"; //s is assigned a reference to a new string object containing "small" 
    s = "bigger"; //s is modified using an overloaded operator
}

Edit, corrected some details and clarified point

See: http://www.cplusplus.com/reference/string/string/ and in particular http://www.cplusplus.com/reference/string/string/operator=/

The assignment results in the original content being dropped and the content of the right side of the operation being copied into the object. similar to doing s.assign("bigger"), but assign has a broader range of acceptable parameters.

To get to your original question, the contents of the object s can have variable size. See http://www.cplusplus.com/reference/string/string/resize/ for more details on this.

Answer 2

It depends on what you mean by "size".

The static size of s (as returned by sizeof(s)) will be the same.

However, the size occupied on the heap will vary between the two cases.

What do you want to do with the information?

Answer 3

i'll say yes and no. s will be the same string instance but it's internal buffer (which is preallocated depending on your STL implementation) will contain a copy of the constant string you wanted to affect to it. Should the constant string (or any other char* or string) have a bigger size than the internal preallocated buffer of s, s buffer will be reallocated depending on string buffer reallocation algorithm implemented in your STL implmentation.

Answer 4

This is going to lead to a dangerous discussion because the concept of "size" is not well defined in your question.

The size of a class s is known at compile time, it's simply the sum of the sizes of it's members + whatever extra information needs to be kept for classes (I'll admit I don't know all the details) The important thing to get out of this, however is the sizeof(s) will NOT change between assignments.

HOWEVER, the memory footprint of s can change during runtime through the use of heap allocations. So as you assign the bigger string to s, it's memory footprint will increase because it will probably need more space allocated on the heap. You should probably try and specify what you want.

Answer 5

i would say this is string object , And it has capability to grow dynamically and vice-versa

Answer 6

The std::string variable never changes its size. It just refers to a different piece of memory with a different size and different data.

Answer 7

A variable is an object we refer to by a name. The "physical" size of an object -- sizeof(s) in this case -- doesn't change, ever. They type is still std::string and the size of a std::string is always constant. However, things like strings and vectors (and other containers for that matter) have a "logical size" that tells us how many elements of some type they store. A string "logically" stores characters. I say "logically" because a string object doesn't really contain the characters directly. Usually it has only a couple of pointers as "physical members". Since the string objects manages a dynamically allocated array of characters and provides proper copy semantics and convenient access to the characters we can thing of those characters as members ("logical members"). Since growing a string is a matter of reallocating memory and updating pointers we don't even need sizeof(s) to change.