Utskrift av char-array via pekare?

Jag har återigen fastnat i C:s sträng/char-träsk. Denna gång har jag en metod som läser tecken från en text-fil m.h.a "fgetc" och lägger dessa tecken i en array. Metoden skall sedan returnera en pekare till denna array för att arrayen inte ska försvinna när metoden är klar. Därefter tar vi emot denna pekare och skriva ut alla tecken. Se nedanstående kod:

Slutet av metoden:

...
post_pek = post; //post_pek är en pekare av typen char och post är char-arrayen
return *(post_pek);

Koden som tar emot pekaren:

*post_pek = post_lasning(infil);
i = 0;
while (post_pek+i != '\0'){
    printf("%s", post_pek);
    post_pek+i;
    i++;
}

Frågan är alltså hur jag skriver ut de tecken (den char-array) som post_pek pekar på?

post_pek är en char-pekare säger du. Du säger också att post är en char-array.

Det betyder att post också är en char-pekare. :)
Dvs. post_pek och post är båda pekare till en char.

post_pek = post; //post_pek är en pekare av typen char och post är char-arrayen
return *(post_pek);

Här returnerar du värdet för post_pek. Inte en pekare till arrayen...

Var skapar du post_pek någonstans? I post_lasning() eller är den global? (aja baja.. ;) )

Jag skulle löst problemet genom att låta post_lasning() även ta in en char-pekare som inargument (glöm inte att nullterminera strängen).

int post_lasning(FILE *file, char *post) { ... }

Klura lite på det och återkom... :bire

Jag skapar post_pek i metoden post_lasning. Varför menar du att jag även ska ta emot char-pekaren som inargument till post_lasning()? Vi skapar för övrigt char-arrayen i post_lasning().

Okej. Såhär gör ni nu om jag fattar det rätt:

Ni skapar en char-array i post_lasning(). Hur skapar ni den?
Skapar ni den statiskt? T.ex:

char post[200]; // Array som får plats med 200 tecken.

Eller skapar ni den dynamiskt genom att allokera minne? T.ex:

char *post = (char *)malloc(sizeof(char)*200);

Gör ni som i mitt första exempel så kommer variabeln post "gå ur scoop" så fort post_lasning() avslutas. Och det är ju inte vad ni vill.

Gör ni däremot som i mitt andra exempel så går det ju givetvis bra att returnera post. MEN glöm då inte bort att deallokera minnet mha. free()!

Nå.. Med tanke på de pekarfrågor du ställer så tror jag ni gjort som i mitt första exempel.

Om ni i förväg vet att antalet tecken ni ska läsa in inte överskrider t.ex. 200 tecken så kan ni skapa en statisk char-array och skicka in den i funktionen post_lasning().

T.ex:

#define MAX_SIZE 200

int post_lasning(FILE *file, char *post, int size)
{
    // Läs in filen och lägg alla tecken i post...
    // size innehåller max antal tecken ni vill läsa.
    // Lämpligen 200 i det här fallet eftersom vi vet
    // att det inte kommer att behöva läsas in fler tecken.
    // Glöm inte att nullterminera!!!

    return 1;
}

...

char post_pek[MAX_SIZE];
int i = 0;

post_lasning(infil, post_pek, MAX_SIZE);

while(post_pek[i] != '\0')
{
    printf("%c", post_pek[i]);
    i++;
}

Variabeln size är alltså en säkerhet så att ni inte börjar skriva utanför allokerat minne. Ni får alltså ha en räknare som räknar antal tecken och ser till att den inte överskrider size's värde (i det här fallet 200).

Klarare nu? Eller så har jag bara gjort dig ännu mer förvirrad. ;)

Red: Gjorde nåt riktigt korkat i while-loopen... ;)