How do you return a char * from two char pointer? Error when returning local pointer. What could be the best procedures to deal with RAW data buffer

Lets say I have a prepend function:

//for example xMessage = "apple";
//for example yMessage = "juice";
//answer should be newMessage = "applejuice"
char* concat(char *xMessage, int xSize, char* yMessage, int ySize){
     char newMessage[xSize+ySize];
     for(....){
        //copyxMessage
     }
     for(....){
        //copyYMessage
     }
    return (char *) newMessage;
}

I know I can use strings, but would preferably keep them as an array of bytes. What could be the best solution for this to avoid the error of returning a local pointer.

SOLUTION: Create a vector or deque of uint8_t depending on the needs of the type of manipulation/algorithms of RAW data. I ended up using a std::vector<uint8_t>. Ex.

std::vector<uint8_t> data(buffer + bytesIn);

Due to in my case receiving data from a socket.

Edit: After reading the replies, the most convenient solution was to create a vector of chars or a string. Since I had a bunch of bytes being sent I decided to go with a std::vector<uint8_t> due to more manipulation I had to do later in the program. Thank you everyone for making me realize that and helping me with this. The reason I was messing with raw char pointers is because the data I was dealing with was RAW data, but converting it into a vector it was easier to manipulate the data, than dealing with char pointers.

Just use std::string

std::string concat(char *xMessage, int xSize, char* yMessage, int ySize){
  std::string s(xMessage);
  s += yMessage;
  return s;
}

If you really want a pointer to the appended string buffer you can use a wrapper around concat.

Note: I absolutely do not agree with doing this, but since you know you can use a std::string but would like to do it with raw pointers, here's one way:

• Allocate a buffer large enough to hold xSize + ySize characters + 1 extra for the terminating \0. You do this with new[].
• std::memcpy the input strings into the allocated buffer.
• Don't forget to delete[] the buffer after use.

#include <cstring>
char* concat(const char *xMessage, int xSize, const char* yMessage, int ySize) {
    char* newMessage = new char[xSize + ySize + 1];
    std::memcpy(newMessage, xMessage, xSize);
    std::memcpy(newMessage + xSize, yMessage, ySize);
    newMessage[xSize + ySize] = '\0';
    return newMessage;
}

Demo

The function declaration

char* concat(char *xMessage, int xSize, char* yMessage, int ySize){

does not make sense.

Firstly, if the arrays pointed to by the pointers xMessage and yMessage are not changed within the function then the corresponding parameters should be declared with qualifier const.

Or if characters from the array pointed to by the parameter yMessage are appended to the array pointed to by the pointer xMessage then in any case the parameter yMessage should be declared with qualifier const.

Secondly, if the parameters xMessage and yMessage point to strings and you need to build a new string that will contain concatenated strings then parameters xSize and ySize are senseless.

If you indeed need to build a string that will contain concatenated passed strings then the function can look the following way

char * concat( const char *xMessage, const char *yMessage )
{
    size_t xLen = strlen( xMessage );
    char *result = new char[ xLen + strlen( yMessage ) + 1 ];
    memcpy( result, xMessage, xLen );
    strcpy( result + xLen, yMessage );
    return result;
}

And the function can be called for example like

char *result = concat( "apple", "juice" );

The caller of the function is responsible for deleting the concatenated string when it will not be required any more like

delete [] result;