Char* combining [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 8 years ago.
Improve this question
I prefer char* instead std::string, so I wrote a function combining char pointers. I created a new project and tested it. It works fine. But when I try to use it in some larger GUI project, my program crashes.
Here's an example (working) code:
#include <Windows.h>
#include <vector>
char *StringJoin(const char *String, const char* ...)
{
va_list ArgList;
va_start(ArgList, String);
std::vector<const char *> StringData;
std::vector<unsigned int> StringLen;
StringData.push_back(String);
unsigned int SingleLength = strlen(String);
StringLen.push_back(SingleLength);
unsigned int TotalLength = SingleLength;
while (1)
{
const char* Val = va_arg(ArgList, const char*);
if (!Val)
break;
StringData.push_back(Val);
SingleLength = strlen(Val);
StringLen.push_back(SingleLength); // In larger projects it crashes here
TotalLength += SingleLength;
}
va_end(ArgList);
char *NewString = new char[TotalLength + 1];
unsigned int VectorSize = StringData.size();
unsigned int NewLength = 0;
for (unsigned int Element = 0; Element < VectorSize; Element++)
{
memcpy(NewString + NewLength, StringData[Element], StringLen[Element]);
NewLength += StringLen[Element];
}
NewString[TotalLength] = '\0';
StringData.clear();
StringLen.clear();
return NewString;
}
int main(void)
{
char* New = StringJoin("Does ", "it ", "works ", "for ", "you ", "?");
printf("%s\n", New);
system("PAUSE");
return 1;
}
Is my code safe and stable?

Answer 1

You can't use the !Val condition:
const char* Val = va_arg(ArgList, const char*);
if (!Val)
break;
When using variable argument list you need to know exactly how many arguments have been passed, or (update) when to stop processing the arguments, using e.g. NULL / nullptr (or any other) sentinel.

Answer 2

You definitely should use variadic templates if your compiler supports it.
The following quite simple function takes an arbitrary number of strings and concatenates it in a loop. It supports both std::string and char* for the arguments (and even mixed):
template<class ...Strings>
std::string StringJoin(Strings ...strings) {
std::string joined;
for (auto s : { strings... })
joined += s;
return joined;
}
Live Demo
Now if you want the result to be a char*, you need to think about where you allocate the memory and where you deallocate it, i.e. you need to manually manage memory. Unless you use smart pointers:
template<class ...Strings>
std::unique_ptr<char[]> StringJoin(Strings ...strings) {
std::string joined;
for (auto s : { strings... })
joined += s;
std::unique_ptr<char[]> buf(new char[joined.size() + 1]);
memcpy(buf.get(), joined.data(), joined.size());
buf[joined.size()] = '\0';
return buf;
}
Live Demo