Vector initializing first element

Lets say I want to initialize the first element of a vector by 5000 bytes.
How to do it? Should I use strcpy or the likes?

Code:

vector<string>big;
char buf[5000];
for(int i=0; i<5000;i++)
   buf[i] = '\0';

strcpy(big[0].c_str(), buf);

or

big.push_back(buf);

You should be able to just write:

Code:

vector<string> big(1, string(5000, '\0'));

Thanks!

Originally Posted by laserlight

You should be able to just write:

Code:

vector<string> big(1, string(5000, '\0'));

This code may be legal, but I dare say it's highly unusual to make a string of 5000 null-termination characters. What good would that do?

>>strcpy(big[0].c_str(), buf);
If your compiler compiles that, then it is broken.
c_str() returns a const char*, which you may not modify.
But then again, why do you need to preallocate? std::string is not a buffer.

Originally Posted by Ducky

Code:

vector<string>big;
char buf[5000];
for(int i=0; i<5000;i++)
   buf[i] = '\0';

strcpy(big[0].c_str(), buf);

this will not compile (you'd know that if you tried), and if you take the necessary steps to make it compile (a very bad idea) it will certainly crash your program for the following reasons:

1. your string vector has not had any space allocated to it yet, and there's no guarantee that the default constuctor allocates a minimum number of elements.
2. the first argument to strcpy() is a char*. std::string::c_str() returns a const char*. you cannot implicitly convert them, and even if you cast away its const-ness, there is no guarantee that the string has any space allocated to it at all, to say nothing of 5000 characters. it is always a sign of bad design and a serious misunderstanding of concepts if you are using strcpy() to copy into a std::string, or in fact if you are using it at all in a C++ program.

laserlight's suggestion is probably the best, but as others have said, why do you need a string filled with 5000 null characters?

Originally Posted by antred

This code may be legal, but I dare say it's highly unusual to make a string of 5000 null-termination characters. What good would that do?

Originally Posted by Elysia

std::string is not a buffer.

I presume that this is deliberate use of std::string as a buffer, though I do wonder why exactly this needs to be in a vector.

@andred
@Elysia
I want to use it instead of a dynamic char* and I will assign it to a char*.
I will post the function in my other thread (still working on it).
Remember Elysia you adviced me to use vector instead of char* for dynamic allocation.

Originally Posted by Ducky

Remember Elysia you adviced me to use vector instead of char* for dynamic allocation.

Yeah, I can't remember exactly where, but the idea is to use a vector of char (not string):
std::vector<char>
This acts like a buffer. You still have to resize it properly before you use it, though (use .resize()).

I think it doesnt matter in my case if its a string or a char* vector because I cannot use it directly in recv(), I have to reassign it to a char*.
And use.resize() will resize the number of elements of the vector not the size of one element.
I only want to use the first element and assign a size to this.

std::string is not supposed to be used as buffer that you can stick stuff into later. You CAN use it that way if you're careful, but it's unusual and awkward. You really should consider a different approach.

You want to use a buffer to receive data. Then, you would do:

std::vector<char> buf(size_of_buf);
// Alternatively: buf.resize(size_of_buf);
foo(&*buf.begin(), buf.size());
// Alternatively: foo(&buf[0], buf.size());

buf.begin() will return an iterator. Iterators can be dereferences to get the element they point at. But then you can take their address.
Since vector is guaranteed to be contiguous, if you get the address of the first element, you have a buffer of .size() elements.

So if I understand well if I put a whole file in the char vector, 1 letter will be 1 element of the vector?
Thats not good for me because I cannot assign that to a char * buf.
Remember I need to assign the vector to a char* pointer.

We are telling you that you can do that.
You have a pointer to a buffer.
A vector is in this case a buffer.
Therefore, the pointer points to the first element in the vector and you have a pointer to your buffer.
But don't do that. Use the vector and its interface instead. I showed you how to fill the vector with data already.

Originally Posted by Ducky

So if I understand well if I put a whole file in the char vector, 1 letter will be 1 element of the vector?
Thats not good for me because I cannot assign that to a char * buf.
Remember I need to assign the vector to a char* pointer.

Code:

void functionThatTakesCharPtr( char* ptr, std::size_t numberOfElements )
{
    for ( std::size_t i = 0; i < numberOfElements; ++i )
    {
         ptr[ i ] = .....;
    }
}

std::vector< char > vec( 5000, '\0' );

functionThatTakesCharPtr( &vec.at( 0 ), vec.size() );

std::vector was specifically designed to be compatible with old C-style interfaces that fiddle around with arrays and pointers.