Pointers som argument til en funktion

Hvilken fejl faar du? Uden at jeg lige har en compiler ved mig, skal du vist ikke dereferer p parameteren i init funktionen.

Segmention fault.

Hvis en funktion skal kunne modificere et argument så den der kalder funktionen kan se det må man give funktionen en pointer (eller reference) til variablen;

void f(TYPE *i)
{
  *i = whatever;
}

Hvis man giver f en normal variabel vil den modificere sin kopi af variablen.

I dit tilfælde er TYPE en int *, så din init skal have en pointer til en int *:
void init(int **p)
{
  *p = (int*)malloc(sizeof(int));
  if (*p == NULL) fatalerror("..");
}

int main()
{
  int *p;
  init(&p);
  destroy(p);
}

Destroy behøver ikke få en int **, den modificerer ikke pointeren.

Et alternativ ville være:

int *init()

Eller nok snarere:

void init(int n,int **p)

og

int *init(int n)

Ok det virker fint nok. Dvs. hvis jeg nu startede med en int i i stedet for int *i ville det vaare:

int main()
{
  int p;
  init(&p);
  destroy(&p);
}

void init(int *p)
{
  p = (int*)malloc(sizeof(int));
  if (p == NULL) fatalerror("..");
}

void destroy(int *p)
{
  free(p);
}

Hm, fejl, prover lige igen :)

int main()
{
  int p;
  init(&p);
  destroy(&p);
}

void init(int *p)
{
  p = (int*)malloc(sizeof(int));
  if (p == NULL) fatalerror("..");
}

void destroy(int *p)
{
  free(&p);
}

Hvad prøver du ?

At have en int* i en int ?

Jeg vil gerne starte med en int p (ift. for hvor jeg for havde en int *p) og saa lave en init og destroy funktion der har typen init(int *p) og destroy(int *p). Udfra bertels eksempel ville jeg tro det blot var at gaa et skridt "tilbage" (altsa **p = *p og *p = p) men saa giver free fejl.

så skal du bruge destroy(int p), men det er efter min bedste overbevisning
en dårlig ide

malloc returnerer en pointer - det er ganske vidt muligt at gemme en pointer i en int,
men det er absolut ikke anbefalelsesværdigt

Det giver ikke rigtigt mening at sætte p (en int) til at være resultatet af en malloc, det du prøver er det samme som:

int p = (int *)malloc(sizeof(int));
free(p);

Hvis ikke i skal være en pointer kunne man lave:

#include <stdio.h>
void init(int *p)
{
  *p = 123;
}
void init2(int p)

{
  p = 444;
}

int main()
{
  int p = 0;
  printf("Before Init: %d\n", p);
  init(&p);
  printf("After Init: %d\n", p);
  init2(p);
  printf("After Init2: %d\n", p);
}

Bemærk at p (i main) er 123 efter init() og også 123 efter init2.

virker nu. Dem der vil have point kan lægge svar

Det er vel Bertel der har trukket det tunge læs, men et kig i min glas kugle
siger at han nok ikke vil have point, så ...