Jag har hört att det är bättre att lägga variabler på det fria lagringsutrymmet. Titta på dessa exempel:
Exempel 1:

#include <iostream>
using namespace std;

int tal;

int main()
{
tal=3;
cout<<tal;
return 0;
}

Exempel 2:

#include <iostream>
using namespace std;

int *tal=new int;

int main()
{
*tal=3;
cout<<*tal;
delete tal;
tal=0;
return 0;
}

Om jag måste använda variabeln tal i flera andra funktioner över hela mitt projekt, så måste jag deklarera den utanför main(). Men vad är då bäst av de två alternativen?

Alternativ två använder du när du inte vet hur många (eller hur stora) variabler du behöver. I ditt fall vet du ju att det är en int du behöver, och då blir det ju alternativ ett. Men skulle det däremot vara så att du skrev ett program där användaren kan öppna en fil så vet du ju inte när du skriver programmet hur stor filen som användaren tänker öppna kommer vara. Då får du istället använda alternativ två.

En liten anmärkning till att börja med:
Din kod ser på ett visst ställe ut så här:

delete tal;
tal=0;

Att skriva tal=0 är mer eller mindre meningslöst. Det enda tillfälle du skulle behöva göra så är om du använder pekaren i massvis av funktioner, och om du tar bort den med delete under exekveringen (vilket är meningslöst om du bara ska ha en int).

Sedan bör du inte använda globala variabler alls. Särskilt inte om du använder using namespace std utanför en funktion. Om du gör så blir det på gränsen till omöjligt att göra större program.

Det finns tillfällen när globala variabler är att föredra på många sätt, men då bör de hellre placeras i ett namespace som man sedan refererar till:

namespace Global
{
int tal;
}

void EnFunktion ()
{
std::cout << Global::tal;
}

void EnAnnanFunktion ()
{
using namespace Global;
std::cout << tal;
}


Men för att svara på din fråga:
Att använda en pekare är lite mindre effektivt och uttnyttjar (precis som du skriver) ett annat minnesområde.

De enda skäl jag ser till att använda pekare är att man behöver skicka en pekare till ett annat program, att man vill kunna kontrollera när variabeln skall finnas eller att man vill ha ett varierbart antal variabler.

Om du gör det för att kontrollera när variabeln existerar så måste du observera att det inte blir någon minnesförtjänst i ditt fall, eftersom en pekare i sig är lika stor som ett heltal.

Jag skulle, till att börja med, försöka flytta variabeln så att den inte blir global. I andra hand skulle jag lägga in den i en namespace. För en enda int skulle jag tveklöst använda en vanlig variabel.

/Niklas Jansson

Först och främst vill jag tacka för svaren, sen har jag lite mer funderingar.

Jag håller på att programmera ett spel, och då behöver jag använda x_pos och y_pos (positionen på gubben som man styr). Dessa variabler behöver jag använda i en massa olika funktioner, och då har jag gjort dem globala. Men i en bok som jag har står det att man aldrig ska använda globala variabler till nåt, utan man ska använda det fria lagringsutrymmet. Annars blir koden svår att förstå och att underhålla. Jag fattar liksom inte varför. Jag måste ju i alla fall lägga int *x_pos=new int; på samma ställe som int x_pos, för att variabeln ska fungera i alla funktioner. T.ex. i en header-fil: globals.h.

Vi har även börjat med en C++ kurs i skolan nu och där sade läraren att man inte skulle skriva #include <iostream.h> längre, utan man skulle använda using namespace std och skriva #include<iostream> Men han förklarade inte varför, eller vad det egentligen gör. Så jag forstod inte riktigt vad du menade med namespace. (Jag brukar inte använda namespace std)

Men vad ska jag egentligen göra med x_pos och lite andra variabler som jag behöver använda i många funktioner? Vad tycker ni?

Det blir en lång förklaring som jag kortar ner rätt mycket det här:
I C använde man variabler globalt ganska mycket. Man förstod med tiden att det inte funkar i längden, det blir svårare att underhålla osv.

Bjarne Stroustrup skrev C++. Där använder man klasser till väldigt mycket, och man kan dessutom placera information på ett enda ställe.

Problemet var att det är mycket opraktiskt att använda klasser till allt. Det blir mindre effektivt, och ofta är det inte logiskt alls att använda klasser. Men för att då kunna använda funktioner överallt måste det vara globalt. Konstanter och dylikt hamnar också globalt.

I stora projekt, där det ingår globala funktioner och variabler överallt, måste man antingen göra långa namn med mystiska bokstavskombinationer för att kunna särskilja funktioner som utför likartade uppgifter men från olika tillverkare.

Detta ledde till att man började med namnrymder, namespaces. Man definierar en namnrymd så här:

namespace MinRymd
{
...
}

I en namnrymd lägger man funktioner, klasser, variabler osv. som är relaterade till varandra.

För att sedan använda något från en namnrymd skriver man t.ex.

MinRymd::Variabel=2;

Om man skall använda mycket från en namnrymd i en funktion skriver man

using namespace MinRymd;

detta gör så att det som finns i MinRymd automatiskt väljs.

Allting som ingår i C++ standardbibliotek är definierat inom rymden std (står för standard). Man bytte (samtidigt som man uppfann namespaces) namn på alla headerfiler till samma namn fast utan .h.
De gamla C-headerfilerna (t.ex. math.h) tog man också bort .h, men man lade också till ett c framför (math.h blir alltså cmath).

Om man skriver 'using namespace std' utanför en funktion blir namnrymden tillgänglig globalt, dvs man struntar i hela idén bakom namnrymder. Detta är ok för mindre projekt, men man bör anpassa sig efter denna princip.

Hoppas du förstår vad det är och hur det är tänkt att användas nu!

x_pos och y_pos är ganska vanliga variabelnamn, så om du skulle behöva x- eller y-koordinater för andra saker blir det inte särskilt snyggt.

Min rekommendation är att du antingen lägger saker som är specifikt för "gubben" i ett namespace - typ namespace Gubben.

Du kan lätt ändra på gubben genom att använda Gubben::x_pos eller Gubben::y_pos.

Om du skulle behöva använda fler gubbar så kan det vara idé att göra om det till en klass.

PS.
För att definiera funktioner som du lagt i en namespace så skriver du så här:

namespace Gubben
{
void EnFunktion ();
int x_pos;
...
}

void Gubben::EnFunktion ()
{
//här kan du använda x_pos till exempel.
...
}

Den anropas naturligtvis med Gubben:EnFunktion ()
DS.

/Niklas Jansson

Oj! Du verkar veta vad du håller på med Niklas =). Jag får tacka så mycket för svaren. Dom har varit väldigt bra, väldigt snällt av dig att skriva så fylliga svar!

Tackar för berömet. Alltid kul att kunna hjälpa till. Säg gärna till när spelet är klart, så man får se hur det blev :-)

/Niklas Jansson