C / C++ / MFC

<pre>
char * CLASS_LCM1602::BuildMessage(char *&title, int value) {

	// convert int to char
	char buffer[100];
	snprintf(buffer, sizeof(buffer), "%d", value);
#ifdef DEBUG
	cout << " conversion int to char buffer " << +buffer << endl; //TOK 
#endif

	char FullMessage[100];
	// why is this needed ?? strcat won't execute without strcpy first
	strcpy(FullMessage, title);
	cout << "title copy " << FullMessage << endl;
	//append buffer
	strcat(FullMessage, buffer);
	cout << "full message " << FullMessage << endl; // TOK 

this is where I need some help 
this does not makes sense to me 
it compiles , does not execute 

 	strcpy(title, FullMessage);
	cout << "title " << title << endl;

	exit(1);  // temp exit 

	return FullMessage;  // return not used , need to compile 
}

<pre>	
        char *title = "NEW TEST";
	int  value  = 100;
	char *message = i2c.BuildMessage(title, value); // message not used for now 

here is the desired result code 
never gets here 	

	cout << " pass full message "<< +title << endl;

#endif

HWND g_mainWindowHandle;
std::condition_variable g_timerConditional;
std::mutex g_timerLock;
std::atomic<bool>g_turnIsOver;
std::atomic<std::chrono::nanoseconds>g_blackPlayerNanosecondsLeft;
std::atomic<std::chrono::nanoseconds>g_whitePlayerNanosecondsLeft;

void turnTimer(std::atomic<std::chrono::nanosecondsNanosecondsLeft>*activePlayerNanosecondsLeft, 
    Rect*displayRect)
{    
    std::chrono::nanoseconds currentNanosecondsLeft{ activePlayerNanosecondsLeft->load() };
    std::chrono::nanoseconds nanosecondsToNextSecond{ currentNanosecondsLeft % 1000000000 };
    std::chrono::steady_clock::time_point nextSecondBoundary{
        std::chrono::steady_clock::now() + nanosecondsToNextSecond };
    std::unique_lock<std::mutex>lock(g_timerLock);    
    std::cv_status status{
        g_timerConditional.std::condition_variable::wait_until(lock, nextSecondBoundary) };
    while (!g_turnIsOver.load())
    {        
        if (status == std::cv_status::timeout)
        {
            currentNanosecondsLeft -= nanosecondsToNextSecond;
            *activePlayerNanosecondsLeft = currentNanosecondsLeft;
            nanosecondsToNextSecond = std::chrono::nanoseconds(1000000000);
            nextSecondBoundary += nanosecondsToNextSecond;
            InvalidateRect(g_mainWindowHandle, displayRect, FALSE);
        }
        status = g_timerConditional.std::condition_variable::wait_until(lock, nextSecondBoundary);
    }
    currentNanosecondsLeft -= 
        std::chrono::steady_clock::now() - (nextSecondBoundary - nanosecondsToNextSecond);
    *activePlayerNanosecondsLeft = currentNanosecondsLeft;
    g_turnIsOver = false;
    InvalidateRect(g_mainWindowHandle, displayRect, FALSE);
}