Avatar
Martin Kobelka:

Zdravím

nedaří se mi vytvořit dynamickou datovou strukturu v C. Nevíte kde je chyba? Hlási mi to neoprávněný vstup do paměti.

#include <stdio.h>
#include <stdlib.h>

void naplnPole(char *znak)
{
    znak = (char *)malloc(sizeof(char)*10);
}

void zapisDoPole(char *znak)
{
    char *pomocnyZnak;
    int i;
    for(i = 0; i < 10; i++) {
        pomocnyZnak = znak + i;
        *pomocnyZnak = '#';
    }
}

int main(void)
{

    char *znak;
    naplnPole(znak);
    zapisDoPole(znak);

    return 0;

}
 
Odpovědět 23. září 23:26
Avatar
Lukas C#
Redaktor
Avatar
Lukas C#:

Pokud vím tak když předáš metodě parametr, tak se vytvoří jeho kopie a s tou se pak pracuje uvnitř metody. Jakmile metoda skončí, tak tato kopie zaniká. Takže si vytvoříš "char *znak", ale metodě předáš jeho kopii, a metoda alokuje paměť pro tuto kopii pointeru. Tato kopie pointeru se ocitne po skončení metody "out-of-scope" a zaniká => do metody zapisDoPole dáváš neinicializovaný pointer, což vyvolá ten neoprávněný přístup. Udělej to tak, aby ti ta funkce "naplnPole" ten pointer vracela.

 
Nahoru Odpovědět  +1 24. září 0:01
Avatar
Martin Dráb
Redaktor
Avatar
Martin Dráb:

Problém je v tom, že do funkce naplnPole předáváš to tvé dynamické pole hodnotou a ne odkazem. To znamená, že změna hodnoty parametru znak se nedostane ven z té funkce do proměnné znak definované ve funkci main. Musíš tedy upravit funkci naplnPole tak, aby nějakým způsobem vracela novou hodnotu/adresu toho dynamického pole.

Varianta 1: návratová hodnota

char *naplnPole()
{
  return (char *)malloc(sizeof(char)*10);
}

. . .
  znak = naplnPole();
  zapisPole(znak);
. . .

Varianta 2: Výstupní parametr (předávání odkazem)

void naplnPole(char **pznak)
{
  *pznak = (char *)malloc(sizeof(char)*10);
}

. . .

  naplnPole(&znak);
  zapisPole(znak);

V druhé variantě vlastně do funkce naplnPole předáváš adresu proměnná znak definované ve funkci main, takže volaná funkce dokáže na tuto adresu uložit cokoliv (a tím přepsat hodnotu proměnné znak ve fci main, což potřebuješ pro uložení adresy počátku tvého pole).

Akceptované řešení
+20 Zkušeností
+1 bodů
Řešení problému
Nahoru Odpovědět 24. září 0:06
2 + 2 = 5 for extremely large values of 2
Avatar
Odpovídá na Martin Dráb
Martin Kobelka:

Díky. Četl jsem, že s polem se pracuje jako s ukazatelem a mají mnoho společněho. Myslel jsem, že když funkci předám pole, tak je to to samé, jako kdybych ji předal ukazatel.

 
Nahoru Odpovědět 24. září 0:16
Avatar
Martin Dráb
Redaktor
Avatar
Odpovídá na Martin Kobelka
Martin Dráb:

Ano, deklarace

char *x;

a

¨char x[]

jsou téměř ekvivalentní. Nemyslím, že by v tvém případě pomohlo nahrazení ukazatele za pole (ve funkci naplnPole). Mnou navrhovaná druhá varianta řešení v podstatě spočívá v tom, že parametrem té funkce je ukazatel na ukazatel na znak (popř. ukazatel na pole znaků a pole znaků je ukazatel na (první) znak).

Nahoru Odpovědět 24. září 0:52
2 + 2 = 5 for extremely large values of 2
Avatar
Neaktivní uživatel:
/* Dynamicke pole znaku, alokace, zapis, vypis */

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h> // printf()
#include <stdlib.h> // exit(), malloc()

#define SIZE 10

// Prototypy funkci
char * alocMemChar(int vel);
char * naplnPole(char *p, int vel, char c);
char * vypisPole1(char *p, int vel);
char * vypisPole2(char *p, int vel);

int main(int argc, char *argv[]){
        char *pc = NULL;

        pc = alocMemChar(SIZE);
        naplnPole(pc, SIZE, 'a');
        vypisPole1(pc, SIZE);
        printf("\n");
        vypisPole2(pc, SIZE);
        free(pc);
        return 0;
}

// Alokace pameti pro dynamicke pole
char * alocMemChar(int vel) {
        char *p;
        p = (char *)malloc(sizeof(char) * SIZE);
        if (!p) {
                printf("Chyba alokace pameti\n");
                exit(1);
        }
        return p;
}

// Zapis do pole prvnich 10 znaku od znaku c vcetne
char * naplnPole(char *p, int vel, char c){
        int i;
        for (i = 0; i < vel; i++){
                *(p+i) = c + i;
        }
        return p;
}

// Vypis pole indexaci ukazatele
char * vypisPole1(char *p, int vel){
        int i;
        for (i = 0; i < vel; i++){
                printf("%c ", p[i]);
        }
        return p;
}

// Vypis pole ukazatelovou aritmetikou
char * vypisPole2(char *p, int vel) {
        int i;
        for (i = 0; i < vel; i++) {
                printf("%c ", *(p + i));
        }
        return p;
}

Jsou 2 důvody, proč se Ti nedaří vytvořit dynamické pole znaků, naplnit ho a vypsat. A oba spolu úzce souvisí. Ten první už tu byl zmíněn a je to skutečně ten, že ve funkci naplnPole() nedostáváš ukazatel mimo jeho funkci a tudíž nepracuješ s ním. Druhý, a toho jsem si všiml ve více tvých programech, je ten, že mícháš formální parametry se skutečnými hodnotami. Je potřeba rozlišovat jména identifikátorů formálních parametrů od skutečných hodnot. Právě vztah ukazatelů a polí mezi nimi činí jejich implementaci tak jedinečnou a výkonnou. Pole bez indexu je ukazatel na začátek pole. Tuto hodnotu lze pak přiřadit jinému ukazateli a pracovat s prvky pole pomocí ukazatelové aritmetiky. Práce s dynamickým polem, zápis, výpis, viz. kód.

Nahoru Odpovědět 26. září 20:16
Neaktivní uživatelský účet
Avatar
Odpovídá na Martin Kobelka
Neaktivní uživatel:

Ještě dvě důležité věci. Pokud pracuješ s dynamickou pamětí, je třeba ji když už ji nepotřebuješ uvolnit za pomoci free(). Tou druhou je po volání funkcí malloc(), alloc() nebo realloc() testovat zda proběhlo přidělení paměti úspěšně.

Nahoru Odpovědět 26. září 20:23
Neaktivní uživatelský účet
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 7 zpráv z 7.