Just nu i M3-nätverket
Gå till innehåll
Onp

Lite nybörjarfrågor...

Rekommendera Poster

1) Vad är det för skillnad på följande syntaxer?

int& rSomeRef;
int & rSomeRef;
int &rSomeRef;

Det som förvirrar mig är att jag i boken "Lär dig C++ på 3 veckor" läste att när man deklarerar referenser så är ett mellanslag före referensoperatorn obligatoriskt... men i samma bok har jag sett honom använda "int& variabel" som parameter till en funktion.

 

2) Är lite förvirrad vad gäller följande kod:

void Test(char* a, int*  {}

int main()
{
char a[255];
int b = 0;

Test(a, ;

return 0;
}

När jag kompilerar detta får jag felet att b inte kan omvandlas från "int" till "int *". Ändrar jag b till en pekare så går det kompilera. Alltså:

void Test(char* a, int*  {}

int main()
{
char a[255];
int* b = new int;

Test(a, ;

return 0;
}

Varför klagar den inte på a?

 

Dela detta inlägg


Länk till inlägg
Dela på andra webbplatser

1) Det är ingen skillnad. Bara en smakfråga. Du kan skriva på vilket sett du vill.

 

2) Kompilatorn har helt rätt.

 

En pekare är en variabel som adresserar ett visst minnesutrymme.

 

Om du har t ex:

int * a = new int;

så är inte a en integer. Det är adressen till en minnesarea som har plats för en integer.

 

int* a = new int[100];

A är adressen till en minnesarea som kan lagra 100 integers.

 

Du kan sedan använda a som en array.

a[5] = 20;

a[10] = 50;

 

Skriver du utanför den allokerade minnesarean så kommer ditt program att på något sätt krasha. (Eller annat fel).

 

En minnesarea som är allokerad med new måste tas bort mede delete.

Om du bara allokerat en variabel så skall du ta bort den med:

delete a;

 

Om du allokerat flera stycken, t ex 100, så tar du bort det med:

delete [] a;

 

Om du inte tar bort minnet, kommer det att vara reserverat under hela körningen. Då kan det hända att du till slut får slut på minne.

 

Om du skapar en vanlig enkel array som i ditt exempel:

{

int a[4120];

}

 

Den minnesarean kommer automatiskt att frigöras när a frigörs. DVS när den kommer ut ur scope, vid }

 

Om du deklarerar en pekare till a:

int* b = a;

så kommer b att peka på den minnesarean som är allokerad för arrayen a.

 

Den går att använda som en vanlig pekare efter detta.

 

Varför då?

 

Jo.. När du ropar på en funktion. Så vill du inte kopiera en hel array och skicka med som argument. Den kan ju vara 10 MB stor. Men en pekare är bara ett par bytes stor, och hur snabb som helst att kopiera.

 

Pekare är generellt och traditionellt snabbare än att indexera arrayer. På dagens processorer gör det kanske inte så stor skillnad. Dock så är allt som är kraftfullt också avancerat, och det är lätt att missa något, och lite krångligt att hitta felen.

 

Dela detta inlägg


Länk till inlägg
Dela på andra webbplatser

Så vad jag har förstått så skiljer sig array:er sig mot vanliga variabler när det gäller pekare?

 

int a = 6;
int* b = &a;   // b pekar till a

int c[10];
int* d = c;    // här behöver man inte använda &-operatorn
                  // eftersom det blir automatiskt minnesadressen?

 

 

[inlägget ändrat 2004-06-13 11:37:12 av Onp]

Dela detta inlägg


Länk till inlägg
Dela på andra webbplatser

Snarare så är vektorer pekare. c är en pekare till c[0], dvs c == &c[0] och *c == c[0]. Vidare är c[1] samma sak som *(c +1) och c+n är &c[n], om n är ett heltal.

 

Vektorer är alltså egentligen pekare med lite syntaktiskt socker.

 

Dela detta inlägg


Länk till inlägg
Dela på andra webbplatser

int a = 6;

int* b = &a;

 

&a ger adressen för variabeln a. b kommer att peka på adressen.

 

int c[10];

int* d = c;

 

c är redan en adress, så du behöver inte göra om den till en adress.

 

Det du kan göra är motsatt, med *.

För ovan nämda exempel med c och d, så:

int e = *d;

e är värdet som d pekar på. DVS samma som c[0];

 

Om du istället gör:

int e = *(d+1);

så tilldelas e det som d+1 pekar på. DVS c[1];

 

Du kan också flytta en pekare.

d++;

int e = *d;

 

Nu kommer e igen att tilldelas det som d pekar på. Den pekar numera på c+1, dvs c[1];

 

En array är, i praktiken en pekare. Men kompilatorn håller reda på livslängden samt storleken. Kompilatorn avallokerar automatiskt minnet när den försvinner. Du kan också använda sizeof( c ); för att få reda på storleken på c.

 

En statisk array måste du veta storleken på när den deklareras. Det behöver du inte göra med en array som är allokerad med new[].

 

Exempel:

int s = 50;

int a[10]; // OK . a är 10 ints stor

int* b = new int[20]; // OK. b pekar på en array som är 20 ints stor.

int* c = new int; // OK. c pekar på en array som är s ints stor, dvs 50.

int d; // Går inte. En statisk array's storlek måste vara känd när du kompilerar.

 

 

Dela detta inlägg


Länk till inlägg
Dela på andra webbplatser

Ser lite ljusare ut nu... =)

 

Nybörjarböckerna tar inte upp såna här grejer. Jag studerade hans kod i boken och märkte att han stoppade in en vektor som funktionsparameter när parametern skulle vara en pekare. Men han struntade i att förklara det steget :(

 

Dela detta inlägg


Länk till inlägg
Dela på andra webbplatser

Skapa ett konto eller logga in för att kommentera

Du måste vara medlem för att kunna kommentera

Skapa ett konto

Skapa ett nytt konto på vårt forum. Det är lätt!

Registrera ett nytt konto

Logga in

Redan medlem? Logga in här.

Logga in nu



×
×
  • Skapa nytt...