Dvourozměrné pole nebo pole struktur? – C / C++ – Fórum – Programujte.com

Ahoj,

řeším ulohu. Ne opravdu nechi , aby jste ji vyřešili za mne. Jenom potřebuji od zkušenějších poradit.

Na vstupu je víceřádkový vstup. Rozparsuji si jednotlivé řádky vstupu a to tak, že každý řádek obashuje dvě hodnoty první je dejme tomu master což je integer a druhá je posloupnost integeru, která ovšem v každem vstupu může byýt jinak veliká. Ukolem je porovnat ty poslpupnosti zda nejsou stejné a teď řeším jak uložit ten rozparsoavný vstu první mě napadlo dvorozněrné pole ale při definici musím zadat velikost což já těch pospoností různé a pokud bych nadefinovala pole podle největší zase budu mrhat pamětí. Pak mě napadlo použít pole struktur, které bude mít dvě hodnoty master je integer to je jasné a druhé pole bude u každé struktury dynamicky alokované podle aktuální velikosti.

Doufám, že nejsem úplně mimo a děkuji za případné poněty.

Přikláněl bych se k druhému řešení. V C++ bych zvolil místo polí std::vector, ušetří hromadu práce a často i chyb.

hu

Požívám jen C takže dám na vaše doporučení teď mám problém jak dynamicky alokovat velikost toho pole struktur. Jedná se totiž o to že na vstupu mám víceřádkový string, který poté rozparsuji do jednotlivých strukrtu podel daných pravidel. Zdálo by se že mohu vytvoři velikost pole struktur podle počtu '\n' ve vstupu, ale není to tak jednoduché protože ve vstupu může více řádku náležet do jedné struktury. Dá se to nějak dynamicky alokovat?

Zvolit si velikost bloku a pole alokovat a realokovat po těchto blocích. Evidovat kolik je alokováno a kolik je naplněno. Při každém zápisu do pole kontrolovat jeho naplnění. Pokud je pole plné, realokovat o další blok a tak pokračovat do načtení všech položek.

hu

Asi by se dala nejdříve do pole vložit prázdná struktura a ta by se pak naplnila daty ze stringu. Při evidenci naplnění pole mám k dispozici informaci o počtu vložených struktur, současně vím, která je vložena jako poslední.

Pro uspořádání dat ve stringu bych se snažil zvolit jednoduchá pravidla. Čím složitější tato pravidla budou a čím víc je bude doprovázet vyjímek, tím těžší bude parsování stringu.

a ještě se k tomu přidává dynamická alokace stringu v dane strukture, nevim presne totiz jakou velikost má vstupní řetězec muze mit 2 znaky ale taky 60, a program má být usporný na paměť

uff to bude fuska

ty nepíšeš jednu zásadní věc a to je jestli tochceš v dynamických proměnných nebo statických

pokud to druhé je to jednodušší a to výrazně. a pak taky kdo má dělat to roztřídění čísel z řádků do proměnných nebo jestli si to můžeš udělat ručně.

já bych to v Céčku (statické prom.) udělal tak, že když máš více řádků textu a na každém řádku jsou jen číslice

oddělené mezerou - aspoň tak to chápu, a první číslo na každém řádku má být master a další čísla jsou jen posloupnost čísle pak bych si vytvořil strukturu.

typedef struct t_lineItem
{
    int master;
    int sequence[20]={0};  // max. 20 císel na řádku + císlo master
    int sequenceCount; // = 20

    bool validSeq[20]={0};   // rika zda existuje cislo na radku

} lineItem;

a pak pole struktur

    t_lineItem linesArray[100];

a to bych vyplnil hodnotami čísel na řádcích:

    linesArray[0].master = 1;
    linesArray[0].sequenceCount = 20;
    linesArray[0].sequence[0] = 1;  atd... atd. atd...

tohle ale funguje tak, že počet čísel na řádku je pevný a stejně tak je dán i max. počet řádků.

pokud počet čísel na řádku je proměnný pak budeš muset používat proměnnou validSeq ktera rika jestli

cislo na danem radku existuje nebo ne a pochopitlne musis znat predem max. pocet cisel oddelenych mezerou na radku

#7 Jerry
a jeste ta sekvence porovnani  :) prvku rad

    for (i = 0; i < linesArrayCount; ++i) {

            for (k = 0; k < linesArrayCount; ++k) {

                if (i != k) {  // porovnej radu kdyz to neni ta sama

                    if (linesArray[i].sequenceCount == linesArray[k].sequenceCount) {  // pocet cisel v obou radach i a k je stejny lze porovnat

                        identityCount = 0;
                        for (l = 0; l < linesArray[i].sequenceCount; ++l) {

                            if (linesArray[i].sequence[l] == linesArray[k].sequence[l]) {
                                identityCount = identityCount + 1;
                            }// if

                        }// for l
                        if (identityCount == 0) {
                            rady i a k jsou rozdilne
                        }// if

                    }//if

                }// if (i != k)
            }// for k

    }// for

#1 mardon
Nepíšete, jakého výsledku chcete dosáhnout. Možnosti, jak se s daným problémem poprat, máte v principu dvě:

• zvolit si maximální limity, např. maximální délka sekvence, maximální počet řádek a maximální délka řádky ve znacích apod., a při načítání dat je kontrolovat. Pak můžete použít statické struktury (např. to dvojrozměrné pole). Díky tomu se jedná o nejjednodušší řešení, které pro školní projekty většinou stačí (pokud zadání nevyžaduje něco jiného).
• Anebo skutečně musíte vytvořit nějaké dynamické struktury (což je řešení, které je obvykle potřeba v praxi). I zde máte další možnosti: můžete si to držet ve spojových seznamech, "nafukovacích" polích, případně v dalších strukturách. Pokud potřebujete jít touto cestou, důrazně bych doporučil použít C++ a kontejnery v STL. Pokud je C nutnost, nikoliv jen vaše neochota pracovat s C++, pak vám život vůbec nezávidím a vyhraďte si dost času na studium, jak napsat nafukovací pole (doporučení hluchehoucho na větších datech nefunguje, protože má kvadratickou časovou složitost). Anebo použijte spojové seznamy, které se i v C dají udělat celkem snadno.