Passing C style string around function

Question

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;
}

tdammers · Accepted Answer · 2010-09-17 10:59:27Z

9

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.

answered Sep 17, 2010 at 10:59

tdammers

20.7k1 gold badge41 silver badges57 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Tony Delroy · Accepted Answer · 2010-09-17 11:18:15Z

1

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");
}

answered Sep 17, 2010 at 11:18

Tony Delroy

107k16 gold badges188 silver badges265 bronze badges

Comments

Vijay Mathew · Accepted Answer · 2010-09-17 11:06:24Z

0

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.

answered Sep 17, 2010 at 11:06

Vijay Mathew

27.3k4 gold badges66 silver badges95 bronze badges

Comments

Steve Townsend · Accepted Answer · 2010-09-17 11:40:29Z

0

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

answered Sep 17, 2010 at 11:40

Steve Townsend

54.4k9 gold badges100 silver badges145 bronze badges

Collectives™ on Stack Overflow

Passing C style string around function

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related