eac0baa76a28af9a0e4dcc37d98b0321
Jeg har altid ødelagt hvordan man bruger `const int*`, `const int * const` og `int const *` korrekt. Er der et sæt regler, der definerer, hvad man kan og ikke kan gøre?


Jeg vil gerne kende alle do's og alle don'ts med hensyn til assignments, passing til funktionerne osv.


Hvad er forskellen mellem const int*, const int * const og int const *?
=======================================================================


answer-id.com
2021.43
Læs den baglæns (som styret af [Clockwise/Spiral Rule](http://c-faq.com/decl/spiral.anderson.html)):


* `int*` - pegepind til int
* `int const *` - pegepind til const int
* `int * const` - const pointer til int
* `int const * const * const` - const pointer til const int


Nu kan den første `const` være på begge sider af typen, så:


* + == `int const *`.
* `const int * const` == `int const * const`


Hvis du vil gå helt amok, kan du gøre ting som dette:


* `int **` - pegepind til pegepind til int
* `int ** const` - en const pegepind til en pegepind til en int
* `int * const * *` - en pointer til en const pointer til en int
* `int const **` - en pegepind til en pegepind til en const int
* `int * const * * const` - en const pegepind til en const pegepind til en int
* ...


Og for at sikre os, at vi har forstået betydningen af const



```
const int* foo;
int *const bar; //note, you actually need to set the pointer 
                //here because you can't change it later ;)
```

`foo` er en variabel pegepind til et konstant heltal. Dette giver dig mulighed for at ændre det, du peger på, men ikke den værdi, du peger på. Oftest ses dette med C-style strings hvor du har en pointer til en `const char`. Du kan ændre hvilken streng du peger på, men du kan ikke ændre indholdet af disse strings. Dette er vigtigt, når selve strengen befinder sig i datasegmentet i et program og ikke bør ændres.


`bar` er en konstant eller en fast pointer til en værdi, der kan ændres. Dette er ligesom en reference uden det ekstra syntaktiske sukker. På grund af dette faktum vil man normalt bruge en reference, hvor man ville bruge en `T* const` pointer, medmindre man har brug for at tillade `NULL` pointers.


Den generelle regel er, at nøgleordet `const` gælder for det, der går umiddelbart forud for det. Undtagelse, en begyndende `const` gælder for det, der følger efter.


* `const int*` er det samme som `int const*` og betyder **"pointer til konstant int"**.
* `const int* const` er det samme som `int const* const` og betyder **"konstant pegepind til konstant int"**.


**Rediger:**
Hvad angår Dos and Don'ts, hvis [dette svar](https://stackoverflow.com/questions/1142191/how-to-return-const-float-from-a-c-function/1142323#1142323) ikke er nok, kan du så være mere præcis med hensyn til, hvad du ønsker?


Enkel brug af `const`.


Den enkleste anvendelse er at deklarere en navngiven konstant. For at gøre dette, erklærer man en konstant som om det var en variabel, men tilføjer `const` før den. Man skal initialisere den med det samme i konstruktøren, for man kan naturligvis ikke sætte værdien senere, da det ville være at ændre den. F.eks:



```
const int Constant1=96; 
```

vil oprette en heltals-konstant, der ufantastisk nok kaldes `Constant1`, med værdien 96.


Sådanne konstanter er nyttige for parametre, som bruges i programmet, men som ikke behøver at blive ændret efter at programmet er kompileret. Den har en fordel for programmører i forhold til C præprocessorens `#define` kommando, idet den forstås & bruges af selve compileren, og ikke blot erstattes i programteksten af præprocessoren, før den når frem til hovedcompileren, så fejlmeddelelser er meget mere nyttige.


Det virker også med pointers, men man skal være forsigtig hvor `const` for at afgøre om pointeren eller det den peger på er konstant eller begge dele. F.eks:



```
const int * Constant2 
```

erklærer at `Constant2` er variabel pointer til et konstant heltal og:



```
int const * Constant2
```

er en alternativ syntaks, der gør det samme, mens



```
int * const Constant3
```

erklærer, at `Constant3` er en konstant pegepind til en variabel heltal og



```
int const * const Constant4
```

angiver, at `Constant4` er en konstant pegepind til et konstant heltal. Grundlæggende gælder "const" for det, der er til venstre for den (undtagen hvis der ikke er noget der, i hvilket tilfælde det gælder for det, der er til højre for den).


ref: <http://duramecho.com/ComputerInformation/WhyHowCppConst.html>

