How can I concat two char pointers into one?

I wanted to know how can I concat two char pointers and if it is even possible? I have a code here;

    char* partOne = "1234"; // could have a known N number of bytes
    char* partTwo = "5678"; // could have a known M number of bytes

    char newPart[N+M];
    for(int i= 0; i<N; i++){
       newPart[i++] = *partOne++;
    }
    for(int i = N, j=0; j < M; j++){
       newPart[i++] = *partTwo++;
    }

    std::cout << (char *) newPart << std::endl;

Could this be possible to achieve?

Edit:
to be clear on why using char pointers is due to UDP sockets. for example: data I received I have the length of the message in the header

while(!closed){
   int bytesReceived = myApi.readData(); // N bytes
   if(bytesReceived <= 0){
       continue;
   }
   char *buffer = myApi.getBuffer(); // returns char * buffer 
   do{
     if(startOf(buffer)){
      //if true check for length of the message
      int messagelen = getMessageLength(buffer);
      while(bytesReeceived < messagelen){
          char * partialBuffer;
          int partialBytesReceived = myApi.readData(); //M bytes
          if(partialBytesReceived <= 0) continue;
          partialBuffer = myApi.getBuffer();
          .....
          //concat two pointers here

         // update N bytesReceived, N += M;
          
      }
    }
  } while(*buffer != '
while(!closed){
int bytesReceived = myApi.readData(); // N bytes
if(bytesReceived <= 0){
continue;
}
char *buffer = myApi.getBuffer(); // returns char * buffer 
do{
if(startOf(buffer)){
//if true check for length of the message
int messagelen = getMessageLength(buffer);
while(bytesReeceived < messagelen){
char * partialBuffer;
int partialBytesReceived = myApi.readData(); //M bytes
if(partialBytesReceived <= 0) continue;
partialBuffer = myApi.getBuffer();
.....
//concat two pointers here
// update N bytesReceived, N += M;
}
}
} while(*buffer != '\0');
}
');
}

In reality I only have access to the updated char * buffer every time I call it. I want to take into account partial messages coming from a UDP socket and bytes received

The right way is the simple:

int main(){

    std::string partOne = "1234";
    std::string partTwo = "5678";

    std::string newPart = partOne + partTwo;

    std::cout << newPart << std::endl;

}

Since you're using C-style strings (character arrays), you could join them by using strcpy and strcat.

#include <iostream>
#include <cstring>

int main() {
    char* partOne = "1234"; // could have a known N number of bytes
    char* partTwo = "5678"; // could have a known M number of bytes

    // In reality you'd want to use `strlen` and allocate on the heap
    // for this, so that you can deal with any size of buffer
    char newPart[N+M+1];
    // Copy the first string in
    std::strcpy(newPart, partOne);
    // Then add (concatenate) the second string to the end
    std::strcat(newPart, partTwo);

    std::cout << newPart << '\n';
}

However, you should keep in mind that using C-style strings in C++ code is often a bad idea. It would be safer to create std::string objects from the buffers, and join them using the + operator. Doing so would have less risk of buffer overruns and other bugs.

In your case, you want to avoid string concatenation. (You could do that by constructing a std::string and a std::string_view, using start pointer and length for each, then using + operator, but that's pointless copying).

Instead, arrange for the subsequent read to append to the data you already have.

The standard pattern for this goes something like:

char buffer[BUFSIZE];
char *p = buffer;
std::size_t len = sizeof buffer;
while (/*need more data*/) {
    auto bytes_read = read(input_fd, buf, len);
    if (bytes_read <= 0) {
        /* error handling here */
        return FAILURE_CODE;
    }
    p += bytes_read;
    len -= bytes_read;
}

We then have p-buffer bytes stored stored contiguously beginning at buffer.