Come si concatenano due wchar_t * insieme?

Question

Ho una base wchar_t* e sto cercando di aggiungerne un'altra alla fine. Come lo faccio? Non posso usare funzioni deprecate poiché sto trattando gli avvertimenti come errori.

Answer 1

#include <wchar.h> 

wchar_t *wcsncat(wchar_t *ws1, const wchar_t *ws2, size_t n); 

La funzione wcsncat() accoda non più dei primi n caratteri della stringa puntata da ws2 alla fine della stringa puntata da ws1. Se un carattere NULL appare in ws2 prima dei caratteri n, tutti i caratteri fino al carattere NULL vengono aggiunti a ws1. Il primo carattere di ws2 sovrascrive il carattere di terminazione NULL di ws1. Un carattere di terminazione NULL viene sempre aggiunto al risultato e, se gli oggetti utilizzati per la copia si sovrappongono, il comportamento non è definito.

ws1

è la stringa di destinazione terminazione null.

ws2

è la stringa sorgente terminazione Null.

n

è il numero di caratteri da aggiungere.

Answer 2

Il modo più semplice per eseguire questa operazione è wcsncat come indicato in precedenza, ma sembra che ci si impegna a utilizzare le funzionalità "CRT sicure" di Visual C++ 2005 e versioni successive. (Solo Microsoft ha "deprecato" quelle funzioni). In tal caso, utilizzare wcsncat_s, dichiarato in string.h.

Answer 3

perché non utilizzare un std::wstring in primo luogo:

wchar_t *ws1 = foo(), *ws2 = bar(); 
std::wstring s(ws1); 
s += std::wstring(ws2); 
std::wcout << s << std::endl; 

Se necessario, std::wstring::c_str() dà accesso al risultato come const wchar_t*.

Answer 4

Utilizzando le funzioni wstrncat/wcsncat è buono, ma credo che la migliore versione di queste funzioni stringa sono sicuri 'L' quelli creati da Open BSD, vale a dire strlcat e wstrlcat. Con le versioni 'n', puoi finire con una stringa che non ha un terminatore nullo in modo da poter ancora avere problemi di sicurezza. Inoltre, alcune implementazioni azzerano lo spazio inutilizzato nel buffer che può rallentare un po 'le cose.

La pagina di Wikipedia contiene ulteriori informazioni su queste funzioni: Strlcpy et al.. L'unico problema è che queste non sono nelle librerie standard, quindi devi includere tu stesso il codice nel tuo progetto.

Ecco l'origine a una funzione wstrlcat:

 
/* 
* Appends src to string dst of size siz (unlike strncat, siz is the 
* full size of dst, not space left). At most siz-1 characters 
* will be copied. Always NUL terminates (unless siz = siz, truncation occurred. 
*/ 
size_t wstrlcat(wchar_t *dst, const wchar_t *src, size_t siz) 
{ 
     wchar_t *d = dst; 
     const wchar_t *s = src; 
     size_t n = siz; 
     size_t dlen; 

     /* Find the end of dst and adjust bytes left but don't go past end */ 
     while(n-- != 0 && *d != L'\0') { 
       d++; 
     } 

     dlen = d - dst; 
     n = siz - dlen; 

     if (n == 0) { 
       return(dlen + wcslen(s)); 
     } 

     while(*s != L'\0') 
     { 
       if(n != 1) 
       { 
         *d++ = *s; 
         n--; 
       } 
       s++; 
     } 

     *d = '\0'; 
     return(dlen + (s - src));  /* count does not include NUL */ 
}