Jag har pluggat C++ ganska länge nu men jag har aldrig fattat när man ska använda pekare. Jag vet vad det är för något, men när ska man använda dom och vad är dom bra för? Kan någon ge ett bra exempel?

* När du inte vet i förväg hur mycket minne du behöver till en variabel:

char *DagsAttDeklarera(int nStorlek)
{
  char *str = new char[nStorlek];
  return str;
}


* I C finns ju inte referenser, så där använder man alltid pekare när man skickar variabler mellan funktioner.

* En pekare talar ju om en minnesadress, och det gör ju att det blir smidigare... Så här t.ex.:

char str[] = "test, test, test";
char *pekare = str;
// pekare innehåller nu "test, test, test".
pekare += 5;
// pekare innehåller nu "test, test".

Tack för svaret!
Sen undrar jag lite till. Jag kanske är dum nu men titta på följande exempel:
//EXEMPEL1
#include <iostream.h>

int main()
{
int *tal = new int;
return 0;
}

//EXEMPEL2
#include <iostream.h>

int *tal = new int;

int main()
{
return 0;
}
Jag har nämligen läst i en bok att man aldrig ska använda globala variabler, men för att få tal tillgängligt över hela programmet måste man ju lägga den över main() (eller någon annanstans). Det stod att om man deklarerar en variabel på det fria lagringsutrymmet finns den forfarande kvar när man avslutat funktionen. Men om jag inte lägger den ovanför main() så kan jag ju inte använda den överallt i mitt program i alla fall. Så varför inte använda globala variabler? Har det nåt med hastighet att göra? Är det snabbare med variabler på det fria lagringsutrymmet?
Och det här förstod jag inte riktigt:

char str[] = "test, test, test";
char *pekare = str;
// pekare innehåller nu "test, test, test".
pekare += 5;
// pekare innehåller nu "test, test".

Jag antar att jag inte fattar det här med pekare och minneshantering :).

> men för att få tal tillgängligt över hela programmet måste man ju
> lägga den över main() (eller någon annanstans).

Nästan. För att få =variabelnamnet= tillgängligt över hela programmet måste man det, men innehållet har inte den begränsningen.


> Det stod att om man deklarerar en variabel på det fria
> lagringsutrymmet finns den forfarande kvar när man avslutat
> funktionen.

Just. Ett exempel:

int *funktion(void)
{
  int test = 5;
  return &test;
}

int main(void)
{
  int *data = funktion();
  cout << *data;
}

Vad kommer cout i main att visa? Inte så mycket vettigt, för variabeln test skapas ju i "funktion" och när den kommer tillbaka till main finns den inte kvar.

Om vi istället gör så att vi skapar test, fortfarande i "funktion", men på det fria lagringsutrymmet istället så kommer den att finnas kvar när man kommer tillbaka till main.

int *funktion(void)
{
int *test = new int;
  *test = 5;
return test;
}

int main(void)
{
int *data = funktion();
cout << *data;
}

Du kan alltså inte använda variabeln test i main eftersom den inte är global, men du kommer åt dess data, trots att den skapades i en annan funktion om du använder det fria lagringsutrymmet.

Säg till om du inte är med på hur *- och &-tecknen används.


> Så varför inte använda globala variabler?

Det är lätt att göra fel då. Å ena sidan blir det ju "enkelt" eftersom du inte behöver tänka på att skicka värden mellan funktioner eftersom allt är tillgängligt överallt. Men det blir lätt rörigt då, så i slutändan är det inte så enkelt som det verkar.


> Är det snabbare med variabler på det fria lagringsutrymmet?

Variabler på det fria lagringsutrymmet är i synnerhet lämpliga när du inte i förväg vet hur stor variabel du behöver. Säg att du gör ett program som användaren kan öppna filer i. Ibland öppnar användaren en fil som är 253 bytes och ibland en som är 5 megabyte. För att lagra textfilens innehåll måste du skapa en variabel som är anpassad efter den största fil som användaren kan tänkas vilja öppna, och det kanske är 10 megabyte... Så för varje gång du kör programmet reserverar den 10 megabyte minne, oavsett hur stor eller liten fil användaren öppnar.

Och så kan man ju inte ha det, så därför skapar man variabeln på det fria lagringsutrymmet istället, för då kan programmet bestämma hur stor variabeln ska vara i samma ögonblick som den skapas. Programmet kollar då alltså hur stor filen som användaren vill öppna är och skapar sedan en variabel som är precis lika stor.

Så, det är som sagt då det är lämpligt med variabler på det fria lagringsutrymmet. När du bara behöver data tillgängligt i någon annan funktion så skickar du ju över det som ett argument till funktionen.


> Och det här förstod jag inte riktigt:

Var kanske ett lite dåligt exempel. Provar så här istället:

char str[] = "0123456789";
char *pekare = str;
// pekare innehåller nu "0123456789".
pekare += 5;
// pekare innehåller nu "56789".

pekare += 5; gör att minnesadressen ökas med fem, dvs den hoppar fram fem tecken i minnet, så från att tidigare ha pekat på 0123456789 har den därefter hoppat fram till 56789.

Jag har en fråga som jag tror har med detta att göra...

Först frågar jag användaren hur många tal som han vill mata in. Sen ska jag skapa en array, och då skulle det ju vara bra om den arrayen (ursäkta svengelskan) innehåller lika många element som han matade in. Ex:

int main()
{
int antal;
cout << "Mata in antal tal: ";
cin >> antal;
int arr[antal];
//mer kod
}

hur gör jag för att det ska fungera?

MvH Dan "DaPe" Persson

Tack för det fylliga svaret! =) Nu förstår jag det sista exemplet med char str[] = "0123456789"; i alla fall. Det var bra!
Sen när man ska använda variabler på det fria lagringsutrymmet börjar också klarna!
Men sen undrar jag lite igen. Ska de två exemplen du gav ovan visa samma sak, alltså skriva ut 5 och sen avslutas? Bara att den finns kvar när man avslutat funktionen? Fattar liksom inte, men jag ska prova att göra nåt liknande program och testa lite.
Sen det DaPe skrev kan också vara kul att veta. Ska man då göra som du skrev i första svaret, i dagsattdeklarera-funktionen?

> hur gör jag för att det ska fungera?

Så här:

int main()
{
  int antal;
  cout << "Ange antal tal: ";
  cin >> antal;
  int *arr = new int[antal];
  // Mer kod.
  delete [] arr; // När du är klar med arrayen.
}

Det du måste komma ihåg är att med den här metoden försvinner inte variabeln när funktionen är slut, så du måste själv ta bort den med delete.

> Ska de två exemplen du gav ovan visa samma sak, alltså skriva ut 5
> och sen avslutas?

Nej, det är det bara det andra exemplet som gör. I det första så skapas ju variabeln test på vanligt vis, och då finns det ju bara i den funktionen där den skapas och main kommer inte åt den.

Men i det andra exemplet kommer main åt den eftersom den skapas på det fria lagringsutrymmet.

Jag trodde också att det första programmet inte skulle skriva ut någonting, men det gjorde det när jag provade... De två olika exemplen fungerar precis lika för mig. Mystiskt?

> De två olika exemplen fungerar precis lika för mig. Mystiskt?

Egentligen inte, för när en variabel tas bort i C++ tas inte värdet bort, utan minnesområdet som variabeln använder markeras bara som ledigt. Så, värdet ligger ju kvar, ända tills nån annan variabel får det minnesområdet tilldelat och gör något med det, vilket alltså är fullt möjligt, och det är därför man inte ska göra så. Visst kan det, som du såg, fungera ibland, men man får verkligen inte lita på det.

Tomas har utan tvekan fått med det mesta, men en mycket viktig del saknas tyvärr.

>* När du inte vet i förväg hur mycket minne du behöver till en variabel

>* I C finns ju inte referenser, så där använder man alltid pekare när man skickar variabler mellan funktioner.

>* En pekare talar ju om en minnesadress, och det gör ju att det blir smidigare... Så här t.ex.:

Det som saknas är det viktiga fallet när man använder klasser och behöver representera den objektorienterade relationen "känner till". Utan pekare hade detta varit oerhört tidskrävande.
Detta är inte (vilket det kan tyckas vara) identiskt med fallet när man skickar pekare mellan funktioner.

Dessutom finns fallet när man måste kontrollera tilldelning till sig själv i ett objekt. Man har alltså skapat en klass som kräver en speciell form av tilldelning (vanligt exempel är en array).
Detta innebär att man måste kontrollera att man inte förstör arrayen om man skriver saker som:

Array a(20);
a=a;

/Niklas Jansson

> Tomas har utan tvekan fått med det mesta, men en mycket viktig del
> saknas tyvärr.

Inte så konstigt med tanke på att det är C jag programmerar i :-)

Ok. Det var inte meningen att klanka ner på dig eller något. :)

Men om du använder C använder du väl trots allt strukturer och pekare i och till dessa? Det är ju trots allt ganska mycket samma sak.

/Niklas Jansson

Okej. Ska prova lite mer nu. Tack så mycket för svaren! Ni har varit väldigt hjälpsamma!

Om du ska skriva t.ex. en länkad list så är pekare ett måste.