C - naplnění pole – C / C++ – Fórum – Programujte.com

Zdravím,

mám takový menší problém s naplněním pole v C. Mám naplnit pole od dolního po horní index (které nejspíše zadá uživatel) náhodnými čísly typu float. Cyklus jsem sestavila nějak takto:

for(i = dolni; dolni<=horni; i++){
      a = rand() % 999;
      b = rand() % 999;
      pp[i] = (float)a/b;
      printf("%0.2f ", pp[i]);
}

Když spustím program, hlásí mi to u řádku pp[i] = (float)a/b; varování Unhandled exception at 0x00413798 in Modul1.exe: 0xC0000005: Access violation writing location 0xcccccccc. Myslím si, že to bude tím, že pole nemá určenou délku. Pokud zadám třeba dolní 5 a horní 7, tak 0-4 není zadán 8+ taky ne, a tak metoda neví, co tam přiřadit, ale nejsem si tím jistá.

Byla bych ráda za jakoukoliv radu.
Děkuji :)

podmienka vo for-e je bud vzdy pravdiva (alebo vzdy nepravdiva). Tym padom ti vznikde nekonecny cyklus kde sa stale zvysuje hodnota 'i'. Akonahle bude hodnota v 'i' vecsia-rovna ako velkost pola tak sa pokusis zapisat do oblasti pamete ktora ti nepatri (ak je pole na zasobniku tak to spadne az ked pretecie zasobnik, ak je na heape tak spadne az ked natrafis na pamet ktora nebola programom alokovana)

pokud máš v podmínce v cyklu dolni<=horni, tak se předpokládá, že pole má velikost minimálně horni+1

takto přistupuješ na prvek mimo pole, protože se pole indexuje od 0 a né od 1 :)
předpokládám, že horni je velikost pole, protože neuvádíš nikde přesnou deklaraci

No, takže by to měla řešit horni-1? To mi ale taky nejde.

stačí upravit podmínku v cyklu jako dolni<horni .. pokud teda horni nepřesáhne velikost pole

EDIT: ach jsem slepej :D ano.. jak napsal vitamin podemnou :), ale stále platí, že horní nesmí přesáhnout velikost pole

'dolny' aj 'horny'  sa v cykle nemeni, takze hodnota podmienky ( dolny <= horny ) bude vzdy rovnaka (premennu 'dolny' v podmienke musis vymeenit za inu premennu :) ) 

#5 ingiraxo
Taky nejede :))

#6 vitamin
Dneska programuju od rána a mám pocit že mi z toho přemýšlení odchází mozek :)) Chápu teda, že se dolní a horní nemění, ale čím zaměnit dolní, to už nevím :))

#7 Ilhvm
mas len 5 moznosti :)

myslim, že se do toho začínáš zamotávat :D proč zaměnovat dolni? Vzhledem k tomu, ze to delas od rana tak trochu pomuzu =D

řekneme, že pole ma 10 prvku, ty chces naplnit pouze od 4-8 treba...

int pole[10];
int dolni = 4;
int horni = 8;
int i;

srand((unsigned int)time(NULL)); // pokud to tam nemas, tak dopis (init rand() podle casu)

// dolni a horni index nesmi presahnout rozmezi pole
if (dolni >= 0 && horni < sizeof(pole))
{
    // v podmince porovnavas aktualni index tak dlouho, dokud je mensi, nez velikost pole
    // horni index taky nesmi byt 10, protoze tohle pole pracuje s indexy od 0-9
    for (i = dolni; i < horni; i++)
    {
        *(pole + i) = rand() % 999; // staci jeden rand()
        // pripadne: pole[i] = rand() % 999;
    }
}

#9 ingiraxo
aa děkuju :))

Jinak ten rand jsem brala z jiné mojí metody, kde máme funkci, která vrací náhodná čísla typu float od 0 po rozsah, který je typu int, máme využít reálné dělení dvou celých čísel, a tuto funkci máme využít i právě v tomto příkladu. 

No, jelikož ale nevím jak naplnit velikost pole tak vznikl další problém :/

Mám teda kód:

void NaplnPole(float pp[], int dolni, int horni){
	int i, a, b;
	float c;
	int n;

	printf("Zadej velikost pole: ");
	scanf("%d", &n);
	
	printf("\nZadej dolni index: ");
	scanf("%d", &dolni);
	printf("\nZadej horni index: ");
	scanf("%d", &horni);

	srand(time(0));
	
	if (dolni >= 0 && horni < sizeof(pp)) {
		for (i = dolni; i < horni; i++) {
			pp[i] = rand() % 999;
			printf("%d  ", pp[i]);
    }
}

a tuhle metodu pak testuju v main:

int _tmain(int argc, _TCHAR* argv[])
{
	int b, c;
	float *pp;

	NaplnPole(pp, b, c);

	system("PAUSE");
	return 0;
}

Velikost pole bych nastavila v mainu, že by uživatel zadal velikost pole (což mám tady v NaplnPole). Jelikož ale na pole odkazuji pomocí pointeru, tak nevím jak na to.

#11 Ilhvm
#11 Ilhvm

Některý překladače spolknou nastavení velikosti pole za běhu, třeba int pole[n]; ale to je imho prasárna. Měla bys použít dynamickou alokaci pomocí funkce malloc.
int* pp = malloc(sizeof(int) * n); //n je pocet prvku

pokud pak použiješ sizeof(pp) nedostaneš velikost pole ale velikost pointeru v bytech což by mělo bejt vždycky 4 pod win.

Zjistit velikost pole ke kterýmu přistupuješ přes pointer nejde. Jelikož tý funkci pro naplnění předáváš dolní i horní index tak to ani nepotřebuješ. Jenom nesmíš dolní index zadat menší než 0 a horní větší než index posledního prvku. Pokud tohle chceš ošetřit musíš si udělat proměnnou a do ní uložit velikost pole ve chvíli kdy jí zadáš. V tvym případě je to n.

Pokud je tohle na co ses ptala...

pokud předem neznáš velikost pole, tak ho musíš alokovat dynamicky.. to se v C provádí pomocí calloc, protože narozdil od malloc initializuje vsechny prvky

mas 2 moznosti, bud pole vratis přes návratovou hodnotu nebo pres parametr, je to jedno.. ale důlezity je, ze musis vratit i jeho velikost, protoze velikost z dyn. alkovanyho pole nezjistis pres sizeof, kterej ti v tomhle pripade vrati velikost ukazatele, coz budou vzdy 4byte i když pole bude mit 100 prvku

tady mas jednoduchou ukazku, jak vratit pole pres parametr 

void naplPole(float** pole, int* velikost)
{
    scanf("%d", velikost);
    *pole = (float*)calloc(*velikost, sizeof(float));
}

int main()
{
    float* pole = NULL;
    int velikost; // nutno si uchovat i velikost pole

    naplPole(&pole, &velikost);
    free(pole); // nutno rucne dealokovat pole

    return EXIT_SUCCESS;
}

Pointery mi dělají strašný problém, tady v tom jsem úplně mimo, funkce má 3 parametry, pole, dolní a horní, nevím jak do toho zahrnout ještě velikost aby to bylo podle zadání.

#14 Ilhvm
Pokud nechceš velikost pole předávat parametrem může bejt globální.

#12 Luckin
Některý překladače spolknou nastavení velikosti pole za běhu, třeba int pole[n]; ale to je imho prasárna. Měla bys použít dynamickou alokaci pomocí funkce malloc.

Nie niektore, ale vecsina ktore podporuju standart C99+

#16 vitamin
Nemam zkušenosti tolika překladačema, vim jenom že ty novější už to neumí. Používat by se to podle mě nemělo.

Luckin: globalni jo? to je rada nad zlato... kdyz neco nejde. dejme to globalni...

Ilhvm: a čemu presne nerozumis na ukazatelich?

takze rychlo-kurz...

jde o to, ze kazda promenna je umistena v pameti a ma nejakou adresu... a pres tuhle adresu se taky muzes dotazet na promennou.. kdyz chces ziskat hodnotu z adresy, tak pouzijes derefenrenci (ukazatel), pokud chces ziskat adresu z promenny, tak pouzijes referenci (ampersand)

takze.. pokud hodnotu chces vratit z funkci pres parametr, tak to musis na urovni adresy, nikoli hodnoty... proto z funkce vystupuje ukazatel na promennou (adresa) a do funkce musi vstoupit to sami, cili adresa promenny (ne hodnota)

takze takto to asi chces mit 

// pole je ukazatel na ukazatele proto, protoze vraci adresu a zaroven se jedna o pole
// u promennych staci pouze ukazatel
void naplPole(float** pole, int* dolni, int* horni)
{
    // velikost by mela z funkce taky vystoupit, ale pokud jde jen o tohle
    // tak ji muzes ponechat pouze pro tuhle funkci, ale musis se smirit s tim,
    // ze pole uz nikdy neprojdes, pac nebudes znat jeho velikost
    int velikost;

    // lze spojit do jednoho prikazu, ale takto je to prehlednejsi
    scanf("%d", &velikost);
    scanf("%d", dolni);
    scanf("%d", horni);

    // pole se vraci z funkce pres parametr, takze pozadujes adresu
    // calloc (stejne jako malloc) vraci void* (proto pretypovani na typ pole)
    *pole = (float*)calloc(velikost, sizeof(float));

    // podminky, cykly... pokud chces pouzivat horni a dolni promennou,
    // tak musis pristoupit k hodnote tak (*horni) pripadne (*dolni) pres ukazatel
    // if ( ... )
    // for (...) { ... }
}

int main()
{
    // vse, co se deklaruje jako ukazatel by melo byt initialitovany jako 0 (NULL)
    float* pole = NULL;
    int dolni, horni;

    // vstupni parametr do pole jsou adresy, proto musis zadat adresy (ne hodnoty) a to
    // diky referenci, ktery vraci adresu promenny/ukazatele
    naplPole(&pole, &dolni, &horni);
    free(pole);

    return EXIT_SUCCESS;
}

doufam ze to uz je trochu jasny

#15 Luckin
takže prostě nad metodu napíšu int *n? Jak u NaplnPole tak i u main?

#18 ingiraxo
Špatně si mě pochopil. Říkala že nechce velikost předávat parametrem. Ta tvoje funkce určuje velikost pole uvnitř. Pokud by ale velikost byla určena v main a nesměla by se předat jako parametr funkci vyplňující pole (ať už z jakýhokoliv důvodu ale takhle to bylo řečeno) tak jak jinak chceš udělat aby se ta velikost dala použí uvnitř tý funkce.

#20 Luckin
v tomhle pripade ano, musela by velikost byt na vyssi urovni nez tyhle 2 funkce ale myslim ze takovyhle reseni by si ve skole rozhodne nevidel :)

ja stale stejne nevim,jestli ta funkce ma byt void nebo ne... podle me ma vracet pole a ty 3 parametry maji byt velikost,dolni a horni... stale neznam presny zadani, takze improvizuju podle toho co tu vidim :)

#21 ingiraxo
Asi tak nápodobně, možná by bylo dobrý kdyby sem hodila celý zadání. Tohle je moc vytržený z kontextu :D

Když bude funkce vracet pole a velikost se určí vevnitř tak už zas tu velikost nebudeš znát mimo tu funkci což nejspíš bude potřeba. Leda udělat aby ta funkce vracela s polem i jeho velikost, ale to už bys musel dělat strukturu a to je imho trochu přehnaný :D

#22 Luckin
tak velikost pole nepotrebuje pokud to bude slouzit pouze pro to naplneni, ale zas nevim jak to chces vypsat :D
a strukturu k cemu? O_o

v každym pripade psala:

, funkce má 3 parametry, pole, dolní a horní, nevím jak do toho zahrnout ještě velikost aby to bylo podle zadání.

takze tipuju, ze ma vrace pole + ty 3 parametry jako velikost,horni a dolni 

float* naplPole(int* velikost, int* dolni, int* horni) { ... }

a jeste ta funkce ma pravdepodobne byt pouze pro alokaci + zjisteni hodnot a naplnit se ma v mainu nebo v jiny funkci

#23 ingiraxo
Osobně si myslim že ta část programu kde uživatel zadává velikost pole a indexy by neměla bejt uvnitř tý funkce pro naplnění ale v main. Takhle mi to nějak nedává smysl. Pak by se jenom parametrem předala velikost a indexy a ty parametry by ani nemuseli bejt pointery, velikost budeš znát i mimo funkci a pointer na vytvořený pole funkce vrátí.

#24 Luckin
tak jiste ze by to tak bylo lepsi, ale nezname zadani krom tech par kousku co sem dala, takze se tu nebudu dohadovat jakej zpusob z tech desitek moznosti pouzit :D

#25 ingiraxo
Jo ještě k tomu jak ses ptal k čemu strukturu. Myslel sem to tak že by se vytvořila struktura která by v sobě měla pointer na pole a jeho velikost a ta funkce by vrátila instanci tý struktury. Pokud by se ta velikost nesměla předat parametrem a zároveň nebyla globální a určila se uvnitř funkce tak nevidim jinej způsob jak by se dala dostat ven z tý funkce :D ...ale jak řikam, je to přehnaný a jak řikáš ty, zadání neznáme a bez něj to nemá cenu řešit. Pochybuju že by ve škole dělali zadání tak aby se to muselo řešit timhle způsobem.

Napište program, který bude vytvořen pomocí projektu ze tří samostatných modulu. První modul bude obsahovat funkci 'main', druhý modul bude obsahovat funkci s označením (A). Třetí modul bude obsahovat funkce (B), (C), (D), (E). K příslušným zdrojovým souborům vytvořte hlavičkové soubory.

(B) void NaplnPole(float pp[],int dolni, int horni); - funkce naplní pole "pp" od indexu "dolni" po index "horni" náhodnými
                                                                       hodnotami v rozsahu 0 až 999, ale typu float

Takové je zadání.

S tím že potom máme v dalších funkcích pole vypsat, vyhledat prvek, který má mezi indexem dolní a horní největší hodnotu a nakonec pole seřadit.

#28 Ilhvm
Jelikož indexy máš funkci předat tak pochybuju že vstup má bejt uvnitř tý funkce, takže jak velikost tak indexy budeš nejspíš zadávat v main a jelikož funkci nemáš předávat velikost pole tak se obávam pro ní budeš potřebovat globální proměnnou.

podle zadani teda tipuju, ze velikost pole bude pevne dana v main ze?

#30 ingiraxo

Buď zadána uživatelem a nebo pevně daná, v zadání to upřesněno není, takže si můžeme vybrat.

#31 Ilhvm
Pokud je pevně daná tak to můžeš ojebat přes #define size "cislo" na začátku souboru.

Jasně, to chápu, jen co mi dělá pořád problémy jsou ty pointery. Nevím kde je dát a kde ne.

#33 Ilhvm
teoreticky nepotrebujes zadnej pointer teda, ta funkce ma pouze 3 parametry, kde prvni mas pole a pak 2 vstupni hodnoty int

#34 ingiraxo
Jeden pointer tam je, pointer na to pole, jelikož jako parametr funkce je float pp[] to samý jako float* pp.

#35 Luckin
to máš pravdu, ale myslel jsem to tak, že tam nemusí mít žádnou "hvězdičku", prece jen pro ty, kteri neznaji moc ukazatele jsou [] přijatelnejsi :)

#33 Ilhvm

#define VELIKOST 10

// lze napsat i jako "float* pole"
void naplPole(float pole[], int dolni, int horni)
{
    int i;

    if (pole && dolni >= 0 && horni < VELIKOST)
    {
        for (i = dolni; i < horni; i++)
        {
            pole[i] = rand() % 999; // bude float
        }
    }
}

int main()
{
    float pole[VELIKOST];

    srand((unsigned int)time(NULL));

    naplPole(pole, 2, 4);

    return EXIT_SUCCESS;
}

Do tý podmínky bych ještě možná pro jistotu přidal "&& pole" nebo pro lepší viditelnost "&& pole != NULL". Pokud by ta funkce nemusela bejt void tak by bylo dobrý udělat aby vracela bool - true pokud všechno bude v pořádku a false pokud bude nějakej parametr chybně zadanej.

chtělo by to, aby to vracelo bool nebo int, takto by nebyla poznat chyba, ale v zadani je void no... ale i tak si myslim, ze ucel tohodle neni osetrovat kazdou potencialni chybu, ale spis zajistit tu logiku

Ilhvm: pokud jde o ty zbyvajici funkce, tak jsem ti je pred spanim napsal, ale priste uz sama =D 

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

#define VELIKOST 10

void naplPole(float pole[], int dolni, int horni)
{
    int i;

    if (pole && dolni >= 0 && horni < VELIKOST)
    {
        for (i = dolni; i < horni; i++)
        {
            pole[i] = rand() % 999;
        }
    }
}

void vypis(float pole[])
{
    int i;
    
    if (pole)
    {
        for (i = 0; i < VELIKOST; i++)
        {
            printf("%f\n", pole[i]);
        }
    }
}

float vyhledejMax(float pole[], int dolni, int horni)
{
    int i;
    float max = -1;

    if (pole && dolni >= 0 && horni < VELIKOST)
    {
        for (i = dolni; i < horni; i++)
        {
            if (pole[i] > max)
                max = pole[i];
        }
    }
    return max;
}

void serad(float pole[])
{
    int i, j, temp;

    if (pole)
    {
        for (i = 0; i < VELIKOST - 1; i++)
        {
            for (j = 0; j < VELIKOST - i - 1; j++)
            {
                if (pole[j + 1] < pole[j])
                {
                    int temp = pole[j + 1];
                    pole[j + 1] = pole[j];
                    pole[j] = temp;
                }   
            }   
        }
    }
}

int main()
{
    float pole[VELIKOST] = { 0 };
    float max;

    srand((unsigned int)time(NULL));

    naplPole(pole, 2, 8);
    vypis(pole);
    max = vyhledejMax(pole, 4, 9);
    serad(pole);

    return EXIT_SUCCESS;
}

#39 ingiraxo
Jé děkuju moc :)

#39 ingiraxo
Teď mi došlo že v C vlastně bool neni, takže spíš aby vracela int, ale to je fuk :D

Ještě jsem se chtěla zeptat, funkce, která hledá největší prvek mezi indexy dolní a horní, vypadá takto - float* HledejPrvek(float pp[],int dolni, int horni), to znamená, že má vracet adresu toho maximálního prvku, funkci mám teda takto:

float* HledejPrvek(float pp[], int dolni, int horni) {
    int i;
    float max = -1;

    if (pp && dolni >= 0 && horni < N) {
        for (i = dolni; i < horni; i++) {
            if (pp[i] > max)
                max = pp[i];
        }
    }
    return max;
}

V mainu pak:

#define N 10

int _tmain(int argc, _TCHAR* argv[]) {

    float pp[N] = {0};
    float max;

    srand((unsigned int)time(NULL));

    NaplnPole(pp, 2, 8);
    VypisPole(pp, 2, 8);
    max = HledejPrvek(pp, 2, 8);
    UsporadejPole(pp, 2, 8);

    system("PAUSE");
	return 0;
}

No, a teď zase ty pointery .... :))

dej si max jako  float * max a neprirazuj hodnotu ale adresu...   a kdyz srovnavas tak  *max  abys ziskal hodnotu

#42 Ilhvm
a proč vůbec vracíš  adresu na ten prvek? to musí být? podle mě máš vracet pouze tu hodnotu, né ukazatel na ni

pokud teda chceš vracet ukazatel na max. prvek, tak logicky když vracíš ukazatel na float, tak ho musíš přiřadit do ukazatele na float, takže v main float* max = NULL;

#44 ingiraxo
Jojo, v zadání to tak je, že funkce vratí adresu největšího prvku

#45 Ilhvm
Já bych to udělal takhle

float* HledejPrvek(float pp[], int dolni, int horni)
{
    int i;
    int max = 0;

    if (pp && dolni >= 0 && horni < N)
    {
        for (i = dolni; i < horni; i++)
	{
            if (pp[i] > pp[max])
                max = i;
        }
    }
    return &pp[max];
}

Netestoval sem to, ale mělo by to fungovat. Jenom do max neukládáš hodnotu nejvyššího prvku ale jeho index a pak vrátíš &pp[max].

#46 Luckin
A v main to předám jak, když vracím adresu největšího prvku, který je v poli? To nemůžu napsat jako &pp[max] = HledejPrvek(pp, 2, 8) ne?

opět do ukazatele

jinak místo indexu bych spíš uchovával to maxko, je to sice uplne jedno, ale zdá se mi to líp pochopitelný 

float* HledejPrvek(float* pp, int dolni, int horni)
{
    int i;
    float* max = pp + dolni;

    if (pp && dolni >= 0 && horni <= N)
    {
        for (i = dolni + 1; i < horni; i++)
        {
            if (*(pp + i) > *max)
                max = pp + i;
        }
    }
    return max;
}

int main()
{
    float pole[] = { 1,5,3,8,7,4,6,9,2,5 };
    float* max = HledejPrvek(pole, 0, N);
    return EXIT_SUCCESS;
}

Když to napíšu takhle:

float* max = HledejPrvek(pole, 0, N); hodí mi to chybu, když to napíšu takhle:

float* max = NULL;
max = HledejPrvek(pp, 2, 8);

tak se program rozjede, ale nic mi to neprovede, tak já už fakt nevím

#49 Ilhvm
v C musí být deklarace na prvním místě ve funkci, takže nemůžeš volat funkci pro nalezení maxu, pokud pod tím je deklarace další proměnný

to co jsem psal funguje bez problému, zkus si to debugnout a uvidíš kde je chyba... nebo sem hod jak to aktuálně máš teď.. můžeš mít chybu i jinde, než v tý funkci pro vyhledání max

Píše mi to - Error 9 error C2143: syntax error : missing ';' before 'type' - takže to bude úplně nějaká blbost někde.

Main:

int _tmain(int argc, _TCHAR* argv[]) {
        int a;
	float pp[N] = {0};
    
	srand((unsigned int)time(NULL));
	
	RandomFloat(a);
	NaplnPole(pp, 2, 8);
        VypisPole(pp, 2, 8);
	float* max = HledejPrvek(pp, 2, 8);
        // UsporadejPole(pp, 2, 8);

        system("PAUSE");
	return 0;
}

#51 Ilhvm
nebude.. to je to co jsem psal pred chvíli :)

nemůžeš deklaravovat a zárověn initializovat proměnnou max za něčím jiným, než je deklarace... tohle je právě handicap C

takže float* max = NULL; dej třeba pod deklaraci int a;

Žádná změna, mě už tenhle příklad příjde jako nevyřešitelný :D

jak žádná změna.. :D

neřikej, že ti tohle hodí tu samou chybu 

int _tmain(int argc, _TCHAR* argv[]) {
        int a;
        float* max = NULL;
	float pp[N] = { 0 };
    
	srand((unsigned int)time(NULL));
	
	RandomFloat(a);
	NaplnPole(pp, 2, 8);
        VypisPole(pp, 2, 8);
	max = HledejPrvek(pp, 2, 8);
        // UsporadejPole(pp, 2, 8);

        getchar(); // system("PAUSE");
	return 0;
}

#54 ingiraxo
... Jo v pořádku, takhle jsem to udělala předtím, ale max se mi nezobrazilo, teď jsem si všimla, že jsem zapomněla hodit do printf formát čísla :/ Asi přepracovanost :D Nechám to tak jak to mám, i kdybych tam měla potom ještě nějaké chyby, tak už to řešit nebudu, ten příklad už nechci vidět :))

Tak děkuju moc a hlavně za tu trpělivost :)