Newsgroup: it.comp.programmare.win32
Titolo: Concatenazione

Sto provando a concatenare 3 stringhe con la funzione sottoindicata.
Alcune volte funziona altre torna strani caratteri.
Esiste qualche altro sistema meno ingarbugliato affinché:
funzione("prova");
ritorni: "inizioprovafine"
senza lo "\0" finale?
char funzione(char txt[]) {
     char	     prefisso[] = "inizio";
     char	     appendice[] = "fine";
	char	     pck[1024];
	memmove_s(pck, sizeof(pck), prefisso, sizeof(prefisso));
	memmove_s(pck+sizeof(prefisso)-1, sizeof(pck), txt, strlen(txt));
	memmove_s(pck + sizeof(prefisso) + strlen(txt), sizeof(pck), appendice, 
sizeof(appendice));
	return pck;
}


Sì che esiste:
----------------------------
versione ASCII:
char* funzioneA(char* buffer, size_t len, const char* txt)
{
	strcpy_s(buffer, len, "inizio");
	strcat_s(buffer, len, txt);
	strcat_s(buffer, len, "fine");
	return buffer;
}
char txtA[100];
funzioneA(txtA, 100, "prova");
----------------------------
versione UNICODE:
wchar_t* funzioneW(wchar_t* buffer, size_t len, const wchar_t* txt)
{
	wcscpy_s(buffer, len, L"inizio");
	wcscat_s(buffer, len, txt);
	wcscat_s(buffer, len, L"fine");
	return buffer;
}
wchar_t txtW[100];
funzioneW(txtW, 100, L"prova");
----------------------------
versione che funziona sia in ASCII che in UNICODE, in base al Character 
Set del progetto (o meglio, UNICODE definito o meno):
TCHAR* funzioneT(TCHAR* buffer, size_t len, const TCHAR* txt)
{
	_tcscpy_s(buffer, len, TEXT("inizio"));
	_tcscat_s(buffer, len, txt);
	_tcscat_s(buffer, len, TEXT("fine"));
	return buffer;
}
TCHAR txtT[100];
funzioneT(txtT, 100, TEXT("prova"));
----------------------------
versione che usa std::string, per evitare "rogne" con le stringhe:
#include <string>
std::string funzione(const char* txt)
{
	std::string buffer = "inizio";
	buffer += txt;
	buffer += "fine";
	return buffer;
}
std::string txt = funzione("prova");
Ti consiglio di approfondire std::string, per evitare di lavorare con 
gli array di caratteri.

 }
questo non funziona. Non dovrebbe neanche compilare perché ritorni un 
array dove avevi dichiarato un char.
Se ti venisse la malsana idea di cambiare il tipo di ritorno da char a 
char*, cascheresti dalla padella alla brace perchè avresti un UB in 
quanto ritorneresti l'indirizzo di un array sullo stack che potrebbe 
contenere qualsiasi cosa.
La sfortuna vuole che probabilmente in certi casi potrebbe contenere 
proprio quello che ti aspetti e indurti a pensare che funzioni...
Comunque il compilatore ti dovrebbe avvertire almeno con una warning tipo:
warning C4172: returning address of local variable or temporary
HTH

}
Ti consiglio di approfondire efficacemente il tuo livello di
preparazione perche errori simili li fanno solo i principianti.

 Non so se dipende dal server o dalla concatenazione incerta che faccio.
Non credo proprio che ti possa funzionare, o almeno non in tutti i casi...
Dovresti postare la porzione di codice vera (compilabile) e non quella 
finta che hai scritto (tipo "sizeof prefisso" che palesemente non 
compila), perché altrimenti non penso che qualcuno sia in grado di darti 
maggiori indicazioni.

 appendice, sizeof appendice);
...
Probabilmente non č il tuo problema, ma giusto per completezza ti 
segnalo che sicuramente sono sbagliati tutti quei sizeof pck che passi 
come secondo argomento. Siccome il puntatore di inizio non č pck, devi 
togliere la parte che hai gią usato....

 quella ' la porzione vera e "sizeof prefisso" viene compilata.
Hai ragione.
In effetti io ho sempre usato, e, che ricordi, sempre visto usare, 
sizeof con le parentesi, che va bene in tutti i casi, al contrario della 
versione senza parentesi.
Con strcat e simili, non ti funziona perché l'array prefisso contiene il 
carattere '\0', che nelle stringhe è utilizzato come terminatore, quindi 
strcat e tutte le funzioni che operano su stringhe ti troncano la 
stringa al primo carattere '\0' che trovano.
Poi, come giustamente ti faceva notare GM, nelle ultime 2 memmove_s, 
sizeof pck è sbagliato, perché il secondo parametro è la dimensione del 
buffer da riempire che stai passando, ossia la dimensione residua, visto 
che non stai passando il puntatore al primo elemento del buffer.
Tieni anche conto che prefisso e appendice contengono il carattere '\0' 
terminatore in maniera implicita e nel tuo caso penso che il terminatore 
non lo dovresti copiare sul buffer.
Quindi avresti dovuto scrivere:
memmove_s(pck, sizeof(pck), prefisso, sizeof prefisso - 1);
memmove_s(pck+sizeof prefisso-1, sizeof pck - (sizeof prefisso-1), txt2, 
strlen(txt2));
memmove_s(pck + sizeof(prefisso)-1 + strlen(txt2), sizeof pck + 
(sizeof(prefisso)-1 + strlen(txt2)), appendice, sizeof appendice - 1);
Infine, quale sarebbe il "piccolo problemino per le stringhe con un % 
"mod" 3"?