Thread: 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!

>>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 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.

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.