Hejsan

Är fortfarande ny när det kommer till c++ men lär mig ännu.

Hur får man en funktion att retunera en char array?

Har följande array som jag filler med t.ex. 5 tecken

char test[5];

sen har jag en funktion som fungerar ( att vänta på innehåller i test ). Men lyckas inte få den att returnera värdet.

test = reverse_it(test);

funktionen ser delvis ut så här
<code>
char reverse_char(char nums[])
{
char rev_nums[5];
int j=0;
for(unsigned int i = strlen(nums)-1; i != -1; i--)
{
rev_nums[i] = nums[i];
j++;
}
return rev_nums;
}
</code>

Men det fungerar inte som jag hade tänkt. Hur kan man lösa det?

Tack!

Om vi börjar med att bortse från att din kod har en bugg, finns det tre sätt att lösa det:

1. En array är egentligen en pekare till en viss mängd allokerat utrymme. Det första sättet är att allokera utrymme och lämna tillbaka det:

char * reverse_char(char nums[])
{
	char *rev_nums;
	rev_nums = new char[5]; 

	//så här gjorde man förr i tiden:
	//rev_nums = (char *) malloc(sizeof(char) * 5)

	int j=0;
	for(unsigned int i = strlen(nums)-1; i != -1; i--)
	{
		rev_nums[i] = nums[i];
		j++;
	}
	return rev_nums;
}

Och den används så här:

...
char * result;
result = reverse_char(x);

//...
delete [] result;
//eller som förr i tiden: free(result)

Då måste man hålla reda på att det minnet man får allokerat i funktionen tas bort.


2. Med det andra sättet så tar man istället emot en pekare som man förutsätter har plats:

void reverse_char(char nums[], char * result)
{
	int j=0;
	for(unsigned int i = strlen(nums)-1; i != -1; i--)
	{
		result[i] = nums[i];
		j++;
	}
}

Och anropas:

char x[5], result[5];
reverse_char(x, result);

Den kanske ser lite mer elegant ut, men är livsfarlig om man inte har plats för alla chars.

Det finns också några mellanting mellan de båda, där man tar in en pekare till pekare eller referens till pekare, och ändrar/allokerar i den, men det är ingen viktig variant.

Alltså:
1. Ser förjävlig ut och riskerar att leda till minnesläcka
2. Är elegant men är för farlig att använda.

Vad ska man använda då? Jo:

3. Använd en std::string istället för char-arrayer. Principen är mycket enkel. Se bara till att alla strängar du använder är std::string. Man kan använda enskilda chars, helt ok, men annars bara string. Det finns överhuvudtaget bara två skäl att använda char-arrayer:
- Mycket extrema prestandakrav. Du kommer inte råka ut för det här på mycket länge.
- Kommunikation med äldre kod. Då finns det två konverteringsfunktioner som löser jobbet galant.

Hur ser koden ut med string då?

std::string reverse_char(std::string nums)
{
	std::string result;
	int j=0;
	for(unsigned int i = nums.length(); i != -1; i--)
	{
		result[i] = nums[i];
		// eller hellre:
		//result.at(i) = nums.at(i);
		j++;
	}
	return result;
}

//kan nog även skrivas betydligt kortare med diverse funktioner ur <algorithm>

Och anropas:

std::string x, result
result = reverse_char(x);

Inget minne att ta hand om, inget krångel, allt bara fungerar. (std:: är namespace-grejer. om du kör med "using namespace std" någonstans räcker det att du skriver "string").

Edit: Och det är dessutom så error-prone att jag skrev fel i första allokerings-alternativet! Nu fixat...

std::string reverse_char(std::string nums)
{
	std::string result;
	int j=0;
	for(unsigned int i = nums.length(); i != -1; i--)
	{
		result[i] = nums[i];
		// eller hellre:
		//result.at(i) = nums.at(i);
		j++;
	}
	return result;
}

Den där koden lär ju inte fungera.
result[i] (vilket skall vara result[j]) kommer att skriva utanför strängen (at hade gett ett undantag).
unsigned int != -1 (jag vet att det fungerar men ger antagligen en varning)

Några alternativa lösningar:
1. Tilldela result den gamla strängen först (std::string result(nums)) i lösningen ovan
2. Använd +=
<code=c++>
std::string reverse(const std::string& nums) {
string result;
for (std::string::reverse_iterator it = nums.rbegin(); it != nums.rend(); ++it)
result += *it;
return result;
}
</code>
3. return std::string(nums.rbegin(), nums.rend());

Ja, precis som jag skrev fanns det buggar i hans ursprungliga kod. Jag förklarade bara principen.

För övrigt ska det inte vara unsigned int öht, utan size_t. Om man inte direkt griper efter en string tror jag inte att reverse-iteratorer är det första man föreslå...

Tack för er hjälp! :)