CODEWITHSUNDEEP
c++
Ashley
Ashley

Reputation: 65

Passing C style string around function

I have a situation as below in which I need to pass a C-style string into a function and stored it into a container that needed to be used later on. The container is storing the char*. I couldn't figure out the efficient way to create the memory and store it into the vector. As in overloadedfunctionA (int), I need to create new memory and copy into buffer, and pass into the overloadedfunctionA(char*) which again create new memory and copy into the buffer again. Imagine I have alot of items in int and other types and I am doing twice the work every time. One way to solve it is to copy the logic from overloadedfunctionA(char*) to overloadedfunctionA(int). But it would resulted in alot of repetitive codes. Any ideas on a more efficient way to do this?

Thanks.

int main(){

overloadedfunctionA(5);
overloadedfunctionA("abc");

}

vector<char*> v1;

void overloadedfunctionA(int intA){
 char* buffer = new char[];
 convert int to char in buffer;
 overloadedfunctionA(buffer1); 
 delete buffer;

}

//act as base function that has a lot of logic need to be performed
void overloadedfunctionA(char* string1){
char* buffer = new char[];
copy string to buffer;
insert string into vector1;
}

Upvotes: 0

Views: 815

Answers (4)

Steve Townsend
Steve Townsend

Reputation: 54178

If your strings are long such that copying is likely to be a performance problem, you could consider boost::shared_array as an alternative to std::string. Provided the contents are invariant, this offers a solution where only one copy of the string will need to be held in memory. Note however that you would be trading reference counting overhead for string copying overhead here.

Some compilers may optimize std::string for you this way anyway, so that a single copy is kept and ref-counted until the contents are changed, when a new array is allocated for the modified contents with its refcount decoupled from the original contents

Upvotes: 0

Tony Delroy
Tony Delroy

Reputation: 106244

Hopefully making the earlier solutions easier for you to follow...

#include <vector>
#include <string>
#include <sstream>

std::vector<std::string> the_vector;

// template here... use an overload if you prefer...
template <typename T>
void fn(const T& t)
{
    std::ostringstream oss;
    oss << t;
    the_vector.push_back(t.str());
}

int main()
{
    fn(3);
    fn("whatever");
}

Upvotes: 1

Vijay Mathew
Vijay Mathew

Reputation: 27204

One optimization you can do is to maintain a static hashmap of strings, so that you can use a single instance for duplicate values. Another solution is to use std::string and redeclare overloadedfunctionA(char*) as overloadedfunctionA(const std::string&). Yet another option is to let a Garbage Collector do the memory management.

Upvotes: 0

tdammers
tdammers

Reputation: 20706

For all that's holy, just use std::string internally. You can assign to a std::string from a const char*, and you can access the std::string's underlying C string through the c_str() method. Otherwise, you'd need to write a wrapper class that handles memory allocation for you, and store instances of that class in your vector; but then, std::string already IS such a wrapper class.

Upvotes: 9

Related Questions