Hvad betyder * (stjerne) ?

Her betyder det at words er en pointer, i dette tilfælde er words et array med to elementer, af typen pointer til const char.

Det må du meget gerne uddybe, er kun erfaren indenfor PHP og VB.NET, det er første gang jeg roder med C.

Det vil sige at de to elementer inde i array'et er af typen "char" fordi at man angiver * foran words?

Vil:

int *words[2] = {3, 8}

altså gøre at man på forhånd ved at 3 og 8 er integers fordi de pointer?

Hvad er en "pointer" og hvordan kan de være "pointer til const char"? :)

Const char er så vidt jeg har forstået det der svarer til en public funktion i VB i hvert fald, hvor CHAR så er _et enkelt bogstav_, som jeg ikke kan få til at gå op med "dadada" eksempelvis.

Pointers er referencer til specifikke steder i hukommenlen. Wikipedia har bl.a. en glimrende artikkel om det her: http://en.wikipedia.org/wiki/Pointer

Nej, det to elementer er af typen char, fordi der står char foran, de er pointere pga. *

Vi tager den lige langsomt:
const char *const_char_pointer = "En eller anden tekst";
Her er const_char_pointer en pointer til const char

int int_array[2] = {1, 2};
int_array er et array af 2 int

Kombinerer vi får vi:
const char *array_of_const_char_pointer[2] = {"dadada", "lalala" };

Og pointere:
int some_int = 32;
some_int er en int

int* pointer_to_int = &some_int;
pointer_to_int er en pointer til int, den sættets til at pege på some_int. & tager adressen på, en pointer er en adresse.

int some_other_int = 31;
int* array_of_pointer_to_int[2] = {&some_int, &some_other_int};

Eller:
int* some_int_pointer = &some_int;
int* some_other_int_pointer = &some_other_int;
int* array_of_pointer_to_int[2] = {some_int_pointer, some_other_int_pointer};

Bemærk at typen på "dadada" er af typen const char*

Aah, det oplyste mig en hel del :) !!

Men som du skriver bertel, har placeringen af * lige foran variablens navn eller lige efter datatypen altså afgørelse for om det er en pointer til en datatype (ved placering lige foran variablens navn) eller pointer til evt. anden variabel (i hukommelse) ved efter datatype?

Opret gerne svar :)

Nej.

int i = 321;
int* p = &i;
er det samme som
int *p = &i;
Som igen er det samme som:
int * p = &i;

Hvor man placerer * er mest et spørgsmål om smag og behag. Der er meget få steder hvor mellemrum har nogen betydning i C og C++

Hej mikze

Herunder er oprettet en række variable:

unsigned char ucMyChar;      //En char variabel
unsigned char ucMyArray[3];  //Et array med tre pladser
unsigned char *ucMyPtr1;      //En pointer der kan pege på en char
unsigned char* ucMyPtr2;      //Samme resultat som ovenfor

Det er altså lige meget hvor det asteriske tegn (*) står.

En pointer kan pege på den type den er erklæret som. De to pointere der er oprettet herover kan altså pege på en char.

Lad os visualisere dette lidt for overblikkets skyld.

Først lægger vi data i din variable:

ucMyChar = 12;
ucMyArray[0] = 0x22;
ucMyArray[1] = 0x33;
ucMyArray[2] = 0x44;

ucMyPtr1 = &ucMyArray[0];  // Giver adresse på første element
ucMyPtr2 = ucMyArray;      // Gør det samme som ovenfor

Bemærk at udelader du adressetegnet (&) vil du altid give adressen på først element i dit array.

Herunder er der angivet et billede af din memory.

BEMÆRK at du kan ikke vide hvor de forskellige variable placeres i din memory, men du kan ltid være sikker på at et array er fortløbende.

MEMORY:
------------------------------------------------------------------
        variabel        |    værdi        |      adresse
------------------------------------------------------------------
        ucMyChar        |    12          |    0xFF00 1000
------------------------------------------------------------------
        ucMyArray[0]    |    0x22        |    0xFF00 1001
------------------------------------------------------------------
        ucMyArray[1]    |    0x33        |    0xFF00 1010   
------------------------------------------------------------------
        ucMyArray[2]    |    0x44        |    0xFF00 1011
------------------------------------------------------------------
        ucMyPtr1        |  0xFF00 1001  |    0xFFFF 1000   
------------------------------------------------------------------
        ucMyPtr2        |  0xFF00 1001  |    0xFFFF 1001
------------------------------------------------------------------


Du kan se i din memory a pointerne har værdien som adressen på dit arrays element 0, altså ucMyArray[0].

Du kan så skrive:

*ucMyPtr = 0x99; 

Dette bevirker at du skriver en værdi på den adresse pointeren peger på. din memory ser nu således ud:

MEMORY:
------------------------------------------------------------------
        variabel        |    værdi        |      adresse
------------------------------------------------------------------
        ucMyChar        |    12          |    0xFF00 1000
------------------------------------------------------------------
        ucMyArray[0]    |    0x99        |    0xFF00 1001
------------------------------------------------------------------
        ucMyArray[1]    |    0x33        |    0xFF00 1010   
------------------------------------------------------------------
        ucMyArray[2]    |    0x44        |    0xFF00 1011
------------------------------------------------------------------
        ucMyPtr1        |  0xFF00 1001  |    0xFFFF 1000   
------------------------------------------------------------------
        ucMyPtr2        |  0xFF00 1001  |    0xFFFF 1001
------------------------------------------------------------------


Bemærk værdi blev ændret......


/huk