---

Jeg har ikke forstået mulighederne med dem såvel som hvordan de fungerer og
hvad forskellen er. Er der nogen der kan forklare det på en pædagogisk måde?

---

---

"Jonas Meyer Rasmussen" <meyer@diku.dk> skrev i en meddelelse

> -En pointer kan pege på forskellige objekter
> int a=1,b=2;
> int* c = &a;//c peger på a
> c=&b;//c peger nu på b

Ved C-programmering har jeg altid været vant til at placere (*) som
nedenfor:

int a,b; // Erklæring af variabeler "a"og "b", der er af
typen int
int *pointer = &a; // Erklæring af pointer til int, der initialiseres med
adressen for "a"
*pointer = b; // Tildeling af derefereret pointer med værdien "b"

I C++ ser man f.eks. tit forskellige placeringer (*) og (&) som:
int* pointer = &a;
int * pointer = &a;
int *pointer = &a;

Og for referencer:
int& reference = a;
int & reference = a;
int &reference = a;

Selvom det er ligegyldigt for compileren, er jeg nogen gange i tvivl om,
hvilken placering der er mest hensigtsmæssig.

Er der en gylden regel for placeringen af (*) og (&) ?

Med venlig hilsen
Torben W. Hansen

---

"Jonas Meyer Rasmussen" <meyer@diku.dk> skrev i en meddelelse

> -En pointer kan pege på forskellige objekter
> int a=1,b=2;
> int* c = &a;//c peger på a
> c=&b;//c peger nu på b

Ved C-programmering har jeg altid været vant til at placere (*) som
nedenfor:

int a,b; // Erklæring af variabeler "a"og "b", der er af
typen int
int *pointer = &a; // Erklæring af pointer til int, der initialiseres med
adressen for "a"
*pointer = b; // Tildeling af derefereret pointer med værdien "b"

I C++ ser man f.eks. tit forskellige placeringer (*) og (&) som:
int* pointer = &a;
int * pointer = &a;
int *pointer = &a;

Og for referencer:
int& reference = a;
int & reference = a;
int &reference = a;

Selvom det er ligegyldigt for compileren, er jeg nogen gange i tvivl om,
hvilken placering der er mest hensigtsmæssig.

Er der en gylden regel for placeringen af (*) og (&) ?

Med venlig hilsen
Torben W. Hansen

---

On Wed, 20 Nov 2002 14:21:08 +0100, "Torben W. Hansen"
<mail@ins-intersoft.com> wrote:

>Er der en gylden regel for placeringen af (*) og (&) ?

Da typen er Pointer to int og Reference to int (I dine ovenstående
eksempler) vil jeg mene at det bør være int* og int& da de jo så er en
de af typen, selvom jeg godt ved at det andet er gyldigt :)

Just my 2 cents.

/Brian
http://www.hybreed.net

---

> Ved C-programmering har jeg altid været vant til at placere (*) som
> nedenfor:
>
> int a,b; // Erklæring af variabeler "a"og "b", der er af
> typen int
> int *pointer = &a; // Erklæring af pointer til int, der initialiseres med
> adressen for "a"
> *pointer = b; // Tildeling af derefereret pointer med værdien "b"
>
> I C++ ser man f.eks. tit forskellige placeringer (*) og (&) som:
> int* pointer = &a;
> int * pointer = &a;
> int *pointer = &a;

Den gyldne regel er at skrive det som
int *a, da stjernen hænger sammen med variablen og ikke typen.
int* a,b; giver derfor en pointer til en int i a og en int i b. Hvis man
sætter stjernen der hvor den virker som
int *a, b; så bliver det liidt tydeligere.

---

Torben W. Hansen skrev:

>Selvom det er ligegyldigt for compileren, er jeg nogen gange i tvivl om,
>hvilken placering der er mest hensigtsmæssig.

Ditto.

>Er der en gylden regel for placeringen af (*) og (&) ?

Nej.

Jeg placerer som regel tegnene ved varabelnavnet fordi jeg tænker
på en intpointer som en pointer og ikke som en variabel af typen
intpointer.

Men når jeg så har en funktion der returnerer et eller andet, er
det mest logisk at fortælle at den returnerer en bestemt type,
f.eks.int*.

--
Bertel
http://bertel.lundhansen.dk/   FIDUSO: http://fiduso.dk/

---

"Torben W. Hansen" <mail@ins-intersoft.com> writes:

> Er der en gylden regel for placeringen af (*) og (&) ?

Nu bruger jeg sjældent &, da jeg hovedsageligt programmerer C.

Jeg placerer altid * mellem type og variabelnavn/funktion, på den
måde er der ingen der føler sig snydt. Med typer der involverer et
lige antal *'er, kunne jeg selvfølgelig sætte lige mange stjerner ved
variabelnavn og type, så de begge kunne komme tættere på stjernerne,
men jeg driller dem og sætter dem imellem alligevel.

--
Christian Hemmingsen

---

"Torben W. Hansen" <mail@ins-intersoft.com> skrev i en meddelelse

Tak for besvarelserne...

Jeg er glad for, at jeg ikke er den eneste, der er i tvivl...

Med venlig hilsen
Torben W. Hansen

---

"Torben W. Hansen" <mail@ins-intersoft.com> wrote in message
news:<arg2du$i4c$1@news.cybercity.dk>...

[8<8<8<]
> Er der en gylden regel for placeringen af (*) og (&) ?

Et bud kan findes på

http://www.research.att.com/~bs/bs_faq2.html#whitespace

Venlig hilsen

Mogens Hansen

---

Tak til Mogens Hansen for henvisning vedr. * pointere,

Hermed Bjarne Stroustrup's bud på placering af (*) ved pointere...

Med venlig hilsen
Torben W. Hansen

[Snip]

Is ``int* p;'' right or is ``int *p;'' right?

Both are "right" in the sense that both are valid C and C++ and both have
exactly the same meaning. As far as the language definitions and the
compilers are concerned we could just as well say ``int*p;'' or ``int * p;''
The choice between ``int* p;'' and ``int *p;'' is not about right and wrong,
but about style and emphasis. C emphasized expressions; declarations were
often considered little more than a necessary evil. C++, on the other hand,
has a heavy emphasis on types.

A ``typical C programmer'' writes ``int *p;'' and explains it ``*p is what
is the int'' emphasizing syntax, and may point to the C (and C++)
declaration grammar to argue for the correctness of the style. Indeed, the *
binds to the name p in the grammar.

A ``typical C++ programmer'' writes ``int* p;'' and explains it ``p is a
pointer to an int'' emphasizing type. Indeed the type of p is int*. I
clearly prefer that emphasis and see it as important for using the more
advanced parts of C++ well.

The critical confusion comes (only) when people try to declare several
pointers with a single declaration:

int* p, p1; // probable error: p1 is not an int*

Placing the * closer to the name does not make this kind of error
significantly less likely.
int *p, p1; // probable error?

Declaring one name per declaration minimizes the problem - in particular
when we initialize the variables. People are far less likely to write:
int* p = &i;
int p1 = p; // error: int initialized by int*

And if they do, the compiler will complain.
Whenever something can be done in two ways, someone will be confused.
Whenever something is a matter of taste, discussions can drag on forever.
Stick to one pointer per declaration and always initialize variables and the
source of confusion disappears. See The Design and Evolution of C++ for a
longer discussion of the C declaration syntax.

---

Jonas Meyer Rasmussen <meyer@diku.dk> writes:
> En reference refererer _altid_ til et objekt.(*)
....
> (*) En reference kan snydes til ikke at referere til et objekt:
> int* p = 0;
> int& r = *p;

Hvorfor så overhovedet skelne ? Kan man ikke sige at:

&v er en funktion der returnerer adressen hvor værdien v er.

"int *a;" opretter en uinitialiseret variabel med en "tilfældig" adresse.
"int &v;" giver ingen mening da man aldrig har brug for en
uinitialiseret adresse med en "tilfældig" værdi.

* og & giver kun mening for variable der ligger på heapen.

Så kan man så koncentrere sig om at forstå hvad det egentlig handler
om: at kende forskel på stacken og heapen.

---

"Jonas Nielsen" <jonasn@diku.dk> wrote in message
news:<ltlm3o1i3y.fsf@tigerdyret.se.delta.dk>...
> Jonas Meyer Rasmussen <meyer@diku.dk> writes:

[8<8<8<]
> &v er en funktion der returnerer adressen hvor værdien v er.

Nej.
Det kommer an på hvor & står.

[8<8<8<]
> * og & giver kun mening for variable der ligger på heapen.

Forkert.
Man kan bruge pointer og reference til alle typer variable, uanset om de
ligger på:
* Globale data (Static storage duration)
* Stakken (Automatic storage duration)
* Heapen (Dynamic storage duration)

>
> Så kan man så koncentrere sig om at forstå hvad det egentlig handler
> om: at kende forskel på stacken og heapen.

Forkert.

Venlig hilsen

Mogens Hansen

---

---

Jonas Meyer Rasmussen <meyer@diku.dk> writes:

> "Jonas Nielsen" <jonasn@diku.dk> wrote
> > Jonas Meyer Rasmussen <meyer@diku.dk> writes:
> > > En reference refererer _altid_ til et objekt.(*)
> > ...
> > > (*) En reference kan snydes til ikke at referere til et objekt:
> > > int* p = 0;
> > > int& r = *p;
> >
> > Hvorfor så overhovedet skelne ?
>
> Fordi de forskelle jeg beskrev, er en del af standarden.
> Den skelner, ergo gør vi det også.

Men hvorfor skelner standarden ? Jeg synes ikke at det er en særlig
pædagogisk definition. Hvis ordene står alene er det på ingen måde
klart hvad forskellen på at "pege" og "referere" er.

> > Kan man ikke sige at:
> > &v er en funktion der returnerer adressen hvor værdien v er.
> >
> > "int *a;" opretter en uinitialiseret variabel med en "tilfældig"
> adresse.
> > "int &v;" giver ingen mening da man aldrig har brug for en
> > uinitialiseret adresse med en "tilfældig" værdi.
> >
> > * og & giver kun mening for variable der ligger på heapen.
>
> Det er noget vås. Tænk lidt mere over det, både pegere og referencer
> er meget anvendelige, og anvendes tit, til elementer andre steder end
> heapen.

Ja jeg gav bare en forklaring på hvorfor man ikke kan skrive en "int
&v" uden at give den en værdi. Pointere og referencer er begge
anvendelige, men jeg kan ikke se at det er særligt essentielt om man
kalder dem pointere eller referencer.

Jeg opfatter en variabel på heapen som en del af hukommelsen der kan
referes vha. en pointer/reference. Jeg opfatter variabel på stacken
som en variabel hvor man ikke kan få fat på adressen, da oversætteren
selv regner ud hvilken adresse den skal refere til/pege på. Grunden
til at oversætteren kan regne det ud er at dens adresse altid er
relativ til stackens start.

> > Så kan man så koncentrere sig om at forstå hvad det egentlig handler
> > om: at kende forskel på stacken og heapen.
>
> Nej, det er _ikke_ pointen. Der _er_ forskel på pegere og referencer, og
> det har intet at gøre med hvilket lagerområde man arbejder med.

Ja på et eller andet niveau er der jo, men er det ikke vigtigere at
forstå at de begge dækker over "En variabel hvor man har adgang til
dens adresse" ?

---

> Jeg opfatter en variabel på heapen som en del af hukommelsen der kan
> referes vha. en pointer/reference. Jeg opfatter variabel på stacken
> som en variabel hvor man ikke kan få fat på adressen, da oversætteren
> selv regner ud hvilken adresse den skal refere til/pege på. Grunden
> til at oversætteren kan regne det ud er at dens adresse altid er
> relativ til stackens start.

Man kan godt få adressen da de lokale variabler er relative til stackens
base pointer og ikke dens top elelr bund.
En vars adresse er lig bp/ebp minus Konstant. Denne konstant er fast for en
given lokal variabel og defineret under compile.

---

---

Jonas Meyer Rasmussen <meyer@diku.dk> writes:

> Du kan sagtens få adressen på en variabel på stakken, ligesom du kan
> lave en reference dertil. Du tager helt fejl, det er forhåbentlig
> ikke nogen fra diku der har bildt dig ind, at du ikke kan det?

Ja, ok. Stakken er der bl.a. fordi at man dermed bliver fri for at
(referere til|pege på) de (variable|objekter) der ligger på den. Jeg
har i hvert fald aldrig haft brug for at lave en reference til
stakken. Men, ok. Det er forkert at sige at man ikke kan gøre det.

> Spørgsmålet gik netop på hvad forskellen var, og man må derfor antage at
> læseren har en nogenlunde forståelse for dette grundlæggende spørgsmål du
> stiller.

Spørgsmålet var: Pointere og referencer: Jeg har ikke forstået
mulighederne med dem såvel som hvordan de fungerer og hvad forskellen
er. Er der nogen der kan forklare det på en pædagogisk måde?

---

Den 21 Nov 2002 15:15:38 +0100 skrev Jonas Nielsen:
>Jonas Meyer Rasmussen <meyer@diku.dk> writes:
>
>> Du kan sagtens få adressen på en variabel på stakken, ligesom du kan
>> lave en reference dertil. Du tager helt fejl, det er forhåbentlig
>> ikke nogen fra diku der har bildt dig ind, at du ikke kan det?
>
>Ja, ok. Stakken er der bl.a. fordi at man dermed bliver fri for at
>(referere til|pege på) de (variable|objekter) der ligger på den. Jeg
>har i hvert fald aldrig haft brug for at lave en reference til
>stakken. Men, ok. Det er forkert at sige at man ikke kan gøre det.

Hvad vil du lave en reference til, hvis det ikke skal være et objekt
på stakken?

Bort set fra globale variable, kan jeg ikke lige se hvordan du kan lave
en reference til et objekt der ligger andre steder.

Medmindre du snyder, og først tager en pointer, og så sætter din
reference til det pointeren peger på.

Mvh
Kent
--
"Intelligence is the ability to avoid doing work, yet get the work done"
- Linus Torvalds

---

"Jonas Nielsen" <jonasn@diku.dk> wrote in message
news:ltfztv3t6d.fsf@tigerdyret.se.delta.dk...

[8<8<8<]
> Jeg
> har i hvert fald aldrig haft brug for at lave en reference til
> stakken.

Ah, ka' det nu å passe ?

Formelt set hedder det ikke stakken - det er blot en almindelig måde at
implementere variable med "Automatic storage duration". Det vil sige
variable hvor variablens levetid er automatisk styret.

Men bortset fra det, så har du formodentlig ofte brugt referencer til
automatiske objekter:

Et typisk lille begynder program:
<kode - ikke compileret>

#include <iostream>
#include <string>

int main()
{
std::cout << "Hvad er dit navn ?" << std::endl;

std::string navn;
std::cin >> navn;

std::cout << "Hej, " << navn << "!" << std::endl;
}

</kode - ikke compileret>

kunne slet ikke fungere uden brug af referencer til automatiske variable.
Det sker såvel når "navn" læses som når "navn" skrive igen.

Venlig hilsen

Mogens Hansen

---

Thomas wrote:

> Jeg har ikke forstået mulighederne med dem såvel som hvordan de fungerer
> og hvad forskellen er. Er der nogen der kan forklare det på en pædagogisk
> måde?

Denne side, synes jeg har ret pædagogisk, man kan nemmere huske forskellene,
fordele og ulemper efter at have læst det:

http://www.parashift.com/c++-faq-lite/references.html

- Morten.