how to fill vector with char* strings

hello all
im trying to add char* text into std::vector
but im keep getting compilations errors , basally i need to keep dynamically container that holds char* strings

Code:

---

static std::vector<char*> v;
....
....
char *name =  getName();
setVector(name);
//then i have the inline function that handle the vector operation

 
inline void setVector(const char* c){
    myClass::v.push_back(c);
}

---

the error im keep getting is :
error C2664: 'push_back' : cannot convert parameter 1 from 'const char *' to 'const char &'
Reason: cannot convert from 'const char *' to 'const char'
This conversion requires a reinterpret_cast, a C-style cast or function-style cast

what im doing wrong here ?
is it the best way to keep char* text in container ?

Nope, the best way is std::string.
std::vector<std::string>

andif i like to have dynamic structure to contain char* what can i do ?

Code:

---

// just make a vector of string
vector<string> v;

// and when you need char *, just do this
v[index].c_str();

---

Quote:

---

Originally Posted by manav

Code:

---

// and when you need const char *, just do this
v[index].c_str();

---

---

Slight correction.

>> andif i like to have dynamic structure to contain char* what can i do

I absolutely agree that it makes no sense to use a vector<char *> when a vector<string> is an option. However, if you did need a container of char*, you should manage the memory of the char* strings, using new to allocate each string in the vector, using strcpy to copy the strings into the vector, and using delete[] to free the memory when strings will be removed from the vector.

If you wanted only to hold string literals that won't change and are known at compile time, you can have a vector<const char*> and not worry about memory management.

But really, why would you want vector<char *>?

Or if you need to pass the strings to a C API which will modify them, you could use:

Code:

---

std::vector< std::vector<char> >

---

well all my application is using char* strings ...
what is the difference between using char* and std::string ?
only backward culpability history reasons ?

They are different things.
Char* is a pointer to char.
std::string is a class that manages a string.

Note that string literals such as "hi" is const char* and not char*.
If you use char*, then you must allocate memory using new/malloc and free later. String literals aren't modifiable.

>> only backward culpability history reasons ?

Sort of. Null terminated character arrays are how strings are implemented in C. C++ used them, too, originally, but when the language was standardized ten years ago they included a standard string class.

For the C++ programmer, the string class means you don't have to manage memory (and handle other string-related tasks). This makes it safer, easier to use, and harder to break.

what about size's ?
application that using only char* string will be smaller then one that using string class?

It depends. On most applications the size difference will not be noticeable. If you're already using vectors (which is generally a good idea), then I doubt you'll have a problem.

Chances are, your app might even be faster if it uses std::string, due to some implementation tricks.

Quote:

---

Originally Posted by umen242

what about size's ?
application that using only char* string will be smaller then one that using string class?

---

It depends on the implementation and the compiler, and there aren't any cases I'm aware of where the size difference between using a char array (C-style string) and a String (C++) mattered. A good compiler will optimize away so many things that the differences are minimal.

Quote:

---

Originally Posted by Lithorien

It depends on the implementation and the compiler, and there aren't any cases I'm aware of where the size difference between using a char array (C-style string) and a String (C++) mattered. A good compiler will optimize away so many things that the differences are minimal.

---

Obviously, if you have MANY, MANY short strings [and I'm not talking about hundreds or thousands, but rather 100000 or more, and strings that are sort of 5-10 characters], then you may find that there's a benefit in storing a char * rather than a string object. As soon as the string starts being longer, then it's meaningless to care about the size of the object holding the string, since the overhead is now quite small compared to the string itself. And naturally, if you only have a few hundred or thousands of strings, then storage space of the object itself will probably be so small that it doesn't make any difference.

--
Mats

And actually, if you have such short strings, the small buffer optimization of modern string implementations will kick in and not allocate anything on the heap at all.