Hledání průsečíku – C / C++ – Fórum – Programujte.com

Nejdříve naznačím o co mi v základě jde. Mám nějaký čtverec A, který si rozdělím na čtyři stejně velké čtverce a,b,c,d. Bude mě zajímat kde se nachází rohové souřadnice každého čtverce. Včechny ty souřadnice leží ve čtverkové soustavě.

Pro zjednodušení, každý čtverec identifikuju podle levého horního rohu, takže A má souřadnici 0,0  a konří vpravo dole na 1,1 . Podobně a začíná na 0,0, b na 0,1 , c na 1,0 ,  d na 1,0

No a teď mi jde o nějakou definici čtverců které hledám. Když chci najít všechny čtverce jednoduše stačí zadat levý horní a pravý dolní čili rozsah 0,0-1,1. Tohle je jednoduché a jasné. Dobře, ale co když chci zadat pravidlo, že mě zajímají všechny čtverce kromě a? Tak musím definovat pole rozsahů, kde je popsáno b + c až d. Zjednodušeně řečeno. Jinak číselně dva rozsahy a: {1,0 až 2,1} + b až c: {0,1 až 2,2}.

No a teď pokročme dále. Co když ty čtverce dozdělím dále stejným způsobem? Nebudeme tedy pracovat se 4 čtverci, ale s 4x4 = 16 čtverci. Můj problém se týká toho, že se to začíná komplikovat. Když řeknu, chci vybrat všechny čtverce, je ta definice jednoduchá. Když řeknu, chci vybrat všechny kromě jednoho, je to taky jednoduché. Ale co když si vyberu tři čtverce, které nechci vybrat? Pak musím nějak zjistit (navrhnout funkci a pomocný objekt) jaké čtverce mám vybrat, tedy jak si rozvrhnout ty jednotlivé rozsahy. Je to jako puzzle, akorát že potřebuju vymyslet funkci která dokáže inteligentně vybrat ty čtverce (rohové souřadnice).

Nakonec co když to bude 8x8 (64) nebo 16x16 (256) čtverců pak už to bude o dost komplikovanější.

Takže bych potřeboval pomoct s realizací, protože nemám ani ponětí jak něco takového zrealizovat pomocí C. Jestli by tam měla být nějaká rekurzivní funkce, která zjišťuje minimální hodnoty v "exkluzivních" součadnicích a porovnává hodnoty ve smyčce. Nemám jasnou představu. Rozlišuji exclusivní a inclusivní souřadnice, ale zadání by mohlo být naopak: zadáš co chceš, a výsledkem by bylo co nechceš, ale to asi řešit nebudu a zůstanu jen u té inkluze.

Edit:

Zapoměl jsem napsat, že mě ne vždy zajímá celý čtverec A. Takže pokud bych měl 256x256 čtverců, tak mě bude třeba zajímat pouze určitá oblast a v té budu dělat tu exluzi. Ve skutečnosti těch čtverců může být třeba 4096x4096 a v tom mě bude zajímat nějaká vnořená oblast, kterou bych popsal mopocí vyloučení některých čtverců. Snad jsem tu základní myšlenku popsal.

PS:

Kdyby někdo tápal proč jsem to pojmenoval hledání průsečíku, tak asi proto, že to co chci vyloučit - (a) je průsečík ve čtverci A , zbytek je b,c,d.

PS 2:

Ještě dodám příklady na obrázcích. Červený čtverec je exkluzivní (co máme zadáno že máme hledat), bílé jsou incluzivní (pouze to co mě ve výsledku zajímá). Souřadnice mohou být prakticky jakékoliv, protože oblast hledání může začínat třeba na 256,256 a končit na 264,264

Připojen obrázek.

Připojen obrázek.

Připojen obrázek.

Připojen obrázek.

#1 oxidián
Tvoj príspevok som ani celý nečítal, ale prvé, čo mi napadlo, keď som prečítal možno prvú polovicu, bolo toto: https://palma.strom.sk/12F2/S/ ... je to len úloha a dokonca sa z nejakého dôvodu nedá dostať ani ku Vzorovým ani ku Správným riešeniam, takže ti to asi nepomôže ... ale neviem, možno ti pomôže systém, ktorým také obrázky zaznačujú ... tam by ti mala nejaká jednoduchá rekurzia stačiť ... ale teda nepochopil som presne, o čo ti ide ....

Prohlížeč mi hlásí že ta stránka je nedůvěryhodná.

Zkusit si to představit na papíře, že máš čtverec a tomu dej souřadnice vpravo nahoře. Pak ho rozděl dvěma čárama na 4 rovné čtverce a těm zase přiřaď souřadnice. Pak je znova rozděl a toto opakuj. Mě jde o to, že ve výsledku, až se doberu té konečné úrovně dělení, chci získat pole souřadnic, které budou představovat výběr čtverců.

Já si uvědomil jak je celá ta "úloha" náročná. Nejdříve musím řešit includy a pak až teprve excludy. Až když znám includy (čili zadání) mohu počítat s excludami. Zadání beru ze souboru txt, takže musím nejdříve naparsovat soubor a uložit data. Parsování je lehké ale ukládání dat už tak ne. Ještě než si to napsal, tak mě napadla taková vizuální pomůcka: adresářová struktura (třeba na ramdisku). Jako příklad vytvořím složku A a v ní dvě složky a,b ... anebo číselně: vytvořím složku 0.0 a v ní složky 0.0 a 1.0 uvnitř složky 0.0 pak mohu vytvořit další složku atd. Tento postup je ale z pohledu složky relativní. Vidím číslo složky z pohledu nadsložky, ale nevidím kolikátá složka v dané úrovni to je. Takže bych to měl přepočítat asi tak:

levý horní roh vnořeného čtverce: x*(level-1) , y*(level-1)  .. co je vlevo je -1

pravý dolní čtverec začíná na: x*level , y*level ... co je nahoře je -1

Vezmeme jako příklad čtyři složky a,b,c,d, které jsou ve složce A. Složka b (1,0) na třetí úrovni bude repreznetována složkami: (levý horní roh) 2,0 a (pravý dolní čtverec) 3,1 .

Čtvrtá úroveň 2,0 by byla (levý horní roh) 4,0 a (pravý dolní čtverec) 5,1

Čtvrtá úroveň 3,1 by byla (levý horní roh) 6,2 a (pravý dolní čtverec) 7,3

U toho pravý dolní čtverec nemám napsaný pravý dolní roh, protože souřadnice začíná vlevo nahoře a kdybych dal vpravo dole tak +1 jenže jednička by nesměla být zahrnuta ve výsledku protože to už by byl vedlejší čtverec.

Takže při parsování souboru vždycky jako bych vytvářel novou složku se souřadnicemi, které si vypočítám z toho jak hluboko to je zanořené. Pro konečné výsledky musím nejdříve zjistit jaké je nejhlubší vnoření a všechny čísla nakonec převést na souřadnice nejhlubší úrovně. A z toho pak budu vycházet až budu počítat ty excluze.

Připojen obrázek.

Připojen obrázek.

Připojen obrázek.

Takže budu potřebovat navrhnout model, který bude obsahovat tu vnořenou strukturu, podobně jak je to u adresářů, jenom každá struktura dané  úrovně má držet souřadnice jednoho až čtyř čtverců. Problém který teď řeším: přidělovat pokaždé paměť - v každé úrovni n krát (např. ná 2x2 + 4x4 + 8x8 + 16x16 + 32x32 + 64x64) se zdá trochu moc náročné ne?

Už jsem dostal nápad jak to vyřešit. Ten návrh je nejjednodušší založit na tom, že vycházím z toho konfiguráku, z toho co tam zadal uživatel, který ví o tom kde a jak jsou ty podčtverce utvářeny.

Základem je to, že si vytvořím pomocné 2D pole:

typedef struct  TASK_REQUEST_LEVEL_ {
    TASK_EXCLUSION_TYPE_t type;
    char c; // include constant for completed sub-squares
    char i; // include or exclude constant for incompleted sub-squares (containning sub-squares)
    char e; // exclude constant
} TASK_REQUEST_LEVEL_t;
typedef TASK_REQUEST_LEVEL_t ** TASK_LEVEL_2D_ARR_t;

TASK_REQUEST_LEVEL_t ** tmp_arr;

Kde c je hodnota, která se nastavuje a mění průběžně během parsování toho souboru. Jelikož parsuju postupně od nadřazených čtverců hlouběji, tak každá úroveň má čtyři podčtverce.

Uživatel může vytvořit tři situace:

A) některý podčtverec se includuje nebo excluduje kompletně

B) některý podčtverec se includuje nebo excluduje částečně, tzn, že daný podčtverec je třeba dělit dál na menší díly a obsajuje vnořené úrovně o něm mluvím jako o nekompletním podčtverci.

C) zbude mu některý pod čtverec se kterým nic nedělá a nezajímá ho, to je opak A. Pokud A je include, tak zbytek je exclude.

Písmena ve struktuře odpovídají Ad:

A) c (completed include)

B) i (incomplete include or exclude)

C) e (excluded)

Přičemž z těchto členů má jeden byte (char) jehož hodnota odpovídá některé z těchto kombinací:

Připojen obrázek.

Zabrané podčtverce představují to co se během parsování definuje, to co zbude je nedefinované a nepracuje se s tím. To jsou hodnoty, které jsou uloženy ve členech c,i ,e. Potom potřebuju vytvořit náležité definice (podmínky) které během parsování řeknou co dělat, když přidám do dané úrovně určitý podčtverec (jako exclude, include nebo částečný include), tím změním hodnotu členů. Takto si připravím dočasné pole se  strukturami. První rozměr pole znamená hlavní čtverec či oblast ve které začínám (tj. nejvyšší úroveň). Další rozměr už definuje jednotlivé hloubky této oblasti (podčtverce).

Paměť alokuji takto:

    w->task.tmp_arr = malloc (pointersCount * 20 * sizeof(int) );  // 20 is maxdepth
    int a;
    for (a=0;a<pointersCount;a++){
        w->task.tmp_arr[a] = malloc (20 * sizeof(int) );  // 20 is maxdepth
        w->task.tmp_arr[a][0].type = unspecified;
        w->task.tmp_arr[a][0].c = -1;
        w->task.tmp_arr[a][0].i = -1;
        w->task.tmp_arr[a][0].e = -1;
    }

pointerCount je počet čtverců či oblastí, které chci zpracovat. K tomu obrázku nahoře pokud bereme v úvahu jako příklad jednu oblast, tak pak je pointersCount = 1; V tomhle souřadnice zatím nehrají roli, s tím budu počítat až úplně nakonec, když bude vyplněna ta dočasná struktura. Tato struktura jen popisuje co daný čtverec obsahuje za podčtverce a jak se má program chovat při výpočtu souřadnice.

Po alokaci paměti jsem inicioval jenom nejvyšší úroveň, protože nevím kolik úrovní bude využito. Je tam max. 20 vnořených úrovní. Snad jsem tu alokaci provedl správně, protože mi přišlo zbytečné 20x volat malloc zevnitř zanořené smyčky.

to je blog nebo se na něco ptáš?
 

Tohle úplně miluju, když použijeme jedno písmenko a bez komentáře netušíš k čemu to je

char c; // include constant for completed sub-squares
char i; // include or exclude constant for incompleted sub-squares (containning sub-squares)
char e; // exclude constant

 Pokud pole obsahuje jen pointery, tak uváděj sizeof(int*) .. jinak je težký vytvořit definici jako MAX_DEPTH ? Alokovat vždy nejvyšší možnou úroveň je opravdu efektivní.. spíš použij realloc nebo stl z c++

w->task.tmp_arr[a] = malloc (20 * sizeof(int) );  // 20 is maxdepth

Celý jsem to nečet.. moc dlouhý

#6 ingiraxo
Realloc mi příjde že je daleko míň effektivní a komplikovaný. Já počítám jen s 20*30 byty na čtverec to přece není moc! Taky počítám že těch čtverců tam bude jen několik například 4. A nejsem si jistý s tou alokací, tak jak to mám - tam přece musím přiřadit tu paměť pro strukturu, jinak je tam na konci pointer který nikam neukazuje takže by to nejspíš krachlo. Ale 20x alokovat na strukturu? Já nevím.

správně by si to měl alokovat takto 

tmp_arr = (TASK_REQUEST_LEVEL_ **) calloc(POINTERS_COUNT, sizeof(TASK_REQUEST_LEVEL_*));

for (int i = 0; i < POINTERS_COUNT; i++) {
    tmp_arr[i] = (TASK_REQUEST_LEVEL_ *) malloc(MAX_DEPTH * sizeof(TASK_REQUEST_LEVEL_));

    for (int j = 0; j < MAX_DEPTH; j++) {
        tmp_arr[i][j].c = -1;
        tmp_arr[i][j].i = -1;
        tmp_arr[i][j].e = -1;
    }
}

opět tam děláš chybu, že alokuješ všechny pole pro typ int...

A proč poprvé používáš calloc a ne malloc? Já přece nechci aby to bylo nastavené na 0, já s to budu nastavovat ručně v cyklu. Většina těch struktur nebude použita.

Já to přetypování kdysi dělal, ale pak jsem narazil na situaci, kdy jsem chtěl zkontrolovat jestli se alokace zdařila a proto jsem to přestal používat.

Každopádně dík za ujištění.

#9 oxidián
protože ve sloupcích jsou jen ukazatelé a tam je lepší mít 0 místo nějakýho pseudo čísla

Přetvypovat to musíš vždy, však ti to vrací void*, i kdyby se alokace nezdařila (nikdy se mi to nestalo), tak přetypováním nic nezkazíš

pokud se chceš ujištovat, zda je tam ten objekt nebo ne, tak použivej new z C++, stejně používáš C++ kompilátor

A kdybych to nepřetypoval tak co, krachne to až se budu snažit dostat k té vnořené struktuře?

#11 oxidián
když to nepřetypuješ, tak ti to nepude ani skompilovat pokud ten tmp_arr je TASK_REQUEST_LEVEL_t**

Jak to? Mě to šlo zkompilovat bez problému. To je snad jedno jestli tam dám TASK_REQUEST_LEVEL_** nebo TASK_REQUEST_LEVEL_t** ?

Jinak jsem si při tom parsování souboru uvědomil, jak je zbytečné a neefektivní používat strtok a strTok (vlastní nestatická varianta funkce strtok). Ty dvě funkce totiž neustále provádí zápis do původního bufferu. Tak jsem si vytvořil funkci, která pouze hledá určité znaky, aniž bych cokoliv zapisoval do původního řetězce v momentě kdy naleznu jakýkoliv separator. A od vytvořených podmínek pak odvíjím rozhodování a akce programu. Sice jsem to neměřil, ale z pouhé podstaty že zápis je pomalejší než čtení by to mělo být rychlejší.

A ještě bych se chtěl zeptat k parsování souboru. Mám tam tři řádky:

(x.y) # znaky x,y označují pořadí, ve kterém chcete zadávat údaje, zároveň zde definujete oddělovač
#(x.y) # znaky x,y označují pořadí, ve kterém chcete zadávat údaje, zároveň zde definujete oddělovač
3.4.2+ # celý čtverec 4,2 v zoomu 3

ten druhý je jen testovací řádek. Chci se dostat před pozici 3.4.2 tedy s má ukazovat na 3

 Zkusil jsem toto:

for (;*s != '\0'  && ( *s != '\n'  && (*(s+1) < '0' || *(s+1) > '9') );s++) { }

a s mi ukazuje na začátek druhého řádeku místo na začátek třetího. Co dělám blbě? Cyklus se má opakovat tak dlouho dokud není nalezen konec řádku a za ním nenásleduje číslo. Čili když najdu konec řádku a za ním je číslo, pak přerušit cyklus.

Na strtok by mi nejvíc vadilo, že interně používá globální proměnnou. Existuje i varianta, kde tomu tak není, tuším strtok_s. Že modifikuje původní řetězec by mi vadilo jen v případě, že původní řetězec ještě budu potřebovat nepozměněný. Naproti tomu se strtok a strtok_s obejdou bez kopírování vytvořených podřetězců. Tím program může být i rychlejší s požitím strtok a modifikací původního bufferu.

Neopomenu zopakovat to, co už bylo v jiných vláknech tohoto fóra: předčasná optimalizace je "pro kočku" (bych napsal něco jiného   , ale co je dovoleno bohovi, není dovoleno volovi)

hu

A řešení pro ten cyklus for?

Používal jsem předtím i jednodušší podmínky:

#na začátku souboru:
for (;*s != '\0' && *s != '\@' ;s++) { }
#a dále pak
for (;*s != '\0'  && (*s != '(' && *(s-1) != '\n' ) ;s++) { }
for (;*s != '\0' && ( *s != '$' && *(s-1) != '\n' ) ;s++) {  }
# a tyto mi fungovaly. Pak jsem tam přidal 
for (;*s != '\0'  && ( *s != '\n'  && (*(s+1) < '0' || *(s+1) > '9') );s++) { }
# a ta mi nefunguje tak jak potřebuju

Zkoušel jsem toto:

for (;*s != '\0'  && ( *s != '\n'  && (*(s+1) < '0' && *(s+1) > '9') );s++) { }

nebo

for (;*s != 

'

\0
'  && ( *s != '\n'  && (*(s+1) < '9' && *(s+1) > '0') );s++) { }

a oba mi vracejí:

"x.y) # znaky x,y označují pořadí, ve kterém ...."

s ukazuje na řádek dříve než je to číslo

Podle mě by toto mělo být správně

for (;*s != '
\0
'  && ( *s != '\n'  && (!(*(s+1) >= '0' && *(s+1) <= '9')) );s++) { }

ale stále to nejede tak jak je třeba

Edit:

Tak tento problém jsem vyřešil:

for (;*s != '
\0
'  && (*s != '\n'  || (!(*(s+1) >= '0' && *(s+1) <= '9')) );s++) { }

Tam platí, že jakmile je jedna z těch podmínek které jsou mezi && porušena, tak cyklus se zastaví. Nicméně tím že jsem k děm dalším dvoum dal &&:

*s != '\n' && (!(*(s+1) >= '0' && *(s+1) <= '9'))

tak jakmile byla jedna z nich porušena tak se cyklus ukončil. Za \n následoval # a ten je menší než '0' proto podmínka byla porušena a cyklus se zastavil.

Takže hledám-li dva znaky a více je tam třeba použít || a definici toho co hledám (nikoliv toho co nehledám jak jsem měl původně v pravé části).

PS: Je to k posrání editovat tady ty kódy už by s tím vlastník fóra měl něco udělat a začít používat normální code /code tagy

Řeším teď jedno takové zvláštní chování funkce. Mám kód (uvnitř funkce):

int zoom;

s++; // skip skipChar
zoom = atoi(s);

Ten kód přesunu z hlavní funkce do pomocné funkce:

#define MAX_DEPTH 20
char * checkBegin(WRAPPER_t * w, char *s, char coordSep, int zoom, int SNo){
    s++; // skip skipChar
    zoom = atoi(s);
    if (zoom<0 || zoom>MAX_DEPTH ) {
        printf("task file: incorrect number value representing zoom is present on begin of line: \n%d. Correct zoom: 0 to %d\n",zoom,MAX_DEPTH);
        return -5;
        }

    return s;
}

Ještě pro jistotu deklaruju hlavičku té funkce uvnitř souboru s hlavičkou.

Ale hned na druhém řádku mám odlišný výsledek než v tom původním kódu. Mést 2 je tam 2009226388.

s odkazuje na 0x3e45d7 "3.4.2+ # celý čtverec ...

MAX_DEPTH v kukátku (watch panel) ukazuje: Not available in current context!

Co to znamená a jak se zbavit tohoto problému?

Volám to takto:

s = checkBegin(w, s, coordSep, zoom, SNo);

v místě kde byl předtím ten funční kód

Chtělo by to vidět funkci celou. Ale jeden postřeh: jako parametr funkci předáš int zoom, jeho hodnotu pak změníš. Parametr funkce je sice proměnná a jde s ním tak nakládat, ale při návratu funkce tato proměnná zaniká i se svým obsahem.

Identifikátor zoom má dva významy, což je matoucí:
1. globální proměnná
2. parametr funkce

hu

zoom není globální proměnná, je deklarovaná jako int uvnitř hlavní funkce.

Edit:

Zkoušel jsem:

printf("\n\n%d\n\n",MAX_DEPTH);

vytisklo správné číslo, takže tady problém není. Ale v tom zoom byl problém. Když jsem to udělal jako referenci tak to už funguje. Stejně ale nechápu že to předtím nefungovalo. I když by se nastavené hodnoty později ztratily tak si myslím že to fungovat mělo.

char * checkBegin(WRAPPER_t * w, char *s, char coordSep, int * zoom, int * SNo){
    s++; // skip skipChar
    *zoom = atoi(s);
    printf("\n\n%d\n\n",MAX_DEPTH);
    if (*zoom<0 || *zoom>MAX_DEPTH ) {
        printf("task file: incorrect number value representing zoom is present on begin of line: \n%d. Correct zoom: 0 to %d\n",*zoom,MAX_DEPTH);
        return -5;
        }
    // trochu zkrácené ...

    *SNo++;
    w->task.tmp_arr[*SNo][0].type = *s != '-' ? exclussion : inclussion;
    return s;
}

s = checkBegin(w, s, coordSep, &zoom, &SNo);

zoom není globální proměnná, je deklarovaná jako int uvnitř hlavní funkce.

I v takovém případě má identifikátor dva významy a je to stejně matoucí. Každá z těch funkcí si vytvoří svou proměnnou. Funkce main vytvoří "autovariable" kterou máš pojmenovanou zoom. Při volání funkce checkBegin vznikne další "autovariable" pro parametr také pojmenovaný zoom. Po návratu checkBegin tato druhá "autovatiable" zanikne a s ní i její obsah. První "autovariable", kterou si vytvořila funkce main, zůstane nedotčena.

hu

Já jsem nemluvil o funkci main ale o hlavní funkci jako funkce, která řídí všechno dění uvnitř includovaného souboru .c . Pojem autovariable nechápu.

http://cs.wikipedia.org/wiki/Automatick%C3%A1_prom%C4%9Bnn%C3%A1  

hu

Takže lokální proměnná, ten termín automatická proměnná je dost divný a pro mě matoucí.

Dá se toto nějak zjednodušit?

Jde mi hlavně o  deklaraci **s a následné použití jako (*s)[1] a jako *(*s) už přestává být přehledné. Dá se nastavit pomocná proměnná že bych deklaroval **pBuffer místo **s a s bych pak nastavil aby ukazovalo na **pBuffer takže bych pak k tomu mohl zase přistupovat jednoduše jako s[1] a jako *s?
 

int * checkBegin(WRAPPER_t * w, char **s, char coordSep, int * zoom, int * SNo){
    (*s)++; // skip skipChar
    *zoom = atoi(*s);
    printf("\n\n%d\n\n",MAX_DEPTH);
    if (*zoom<0 || *zoom>MAX_DEPTH ) {
        printf("task file: incorrect number value representing zoom is present on begin of line: \n%d. Correct zoom: 0 to %d\n",*zoom,MAX_DEPTH);
        return -5;
        }

    if ( (*s)[1] == '\0' || (*s)[2] == '\0' ||
         !( (*s)[1] == coordSep ^ (*s)[2] == coordSep ) ) {
        printf("task file: incorrect separator follows zoom number:%.12s\n",s);
        return -6;
        }

    for (;*(*s) != '\0'  &&
           (*(*s) == coordSep  || ( *(*s) >= '0' && *(*s) <= '9')) ;(*s)++) { }
    if ( *(*s) != '+' || *(*s) != '-' ) {
        printf("task file: single line command missing + or - just after the square coordinates: %s.9 Include or exclude area?\n",s);
        return -5;
        }

    *SNo++;
    w->task.tmp_arr[*SNo][0].type = *(*s) != '-' ? exclussion : inclussion;
    return 0;
}

Máš talent řešit věci komplikovaně. Nejdříve by sis měl ujasnit, co funkce má udělat, s jakými parametry to bude dělat, jaké a jak bude předávat výsledky své práce. Domnívám se, že by pak nebylo nutné v parametrech předávat ukazatel na ukazatel. Dále bych se vyhnul "magickým číslům" v návratové hodnotě funkce, ke všemu bez jakéhokoliv komentáře. Chybové kódy, o které se asi jedná, bych si vytvořil jako makra nebo jako výčtový typ a měl je uložené v hlavičkovém souboru spolu s prototypy funkcí a jasným komentářem. Při volání funkcí a testování jejich návratových hodnot pak nepotřebuji vědět faktickou hodnotu chybového kódu, jeho název mi většinou pomůže dosadit "našeptávač" v IDE. Pokud tu hodnotu vědět potřebuji, nebo si nemohu vybavit název makra nebo alespoň začátek názvu, podívám se do hlavičkového souboru.

hu

Lokální proměnné bývají obvykle automatické. Lze to změnit pomocí modifikátorů static (bude statická) nebo register (umístí se do registru).

hu

Já ale nepotřebuji znát význam chybového kódu, je tam printf.

Funkce částečně parsuje a částečně ověřuje některá data ze souboru, a taky je ukládá do objektu. Některé hodnoty není třeba do objektu ukládat protože jsou pouze použity ve funkci která tuto funkci zavolala.

A tak u mě to funguje obráceně než u tebe. Já to řeším nejdříve na úrovni hlavní funkce pak se teprve rozhodnu jestli to přesunu do funkce a při tom jak testuju funkci a kontroluju jestli proměnné obsahují správné hodnoty tak tehdy upravím i ty vstupní argumenty a výstup. Prostě jasno si dělám až během toho co to píšu. Pochybuju že by to šlo udělat bez referencí.

Kazdopadne navratovy typ je pointer na int, a ty do toho cpes nejaky kdo vi jaky magicky result kody. Uz to je tak moc spatne, ze ani nemuzes otestovat NULL.

Dale v C existuje funkce  isdigit(znak),  ktera vrati true, pokud je to '0'-'9', coz by zkratilo ty priserne neprehledny fory (aspon jeden). Taky by byl vhodnejsi while. Aspon by neco delal (tj. inkrementoval). Taky furt resis optimalizace na urovni instrukci a nacpes tam pomalejsi post inkrementaci misto preinkrementace.

ještě si rejpnu: nejsou reference z C++? (kterému se tak úzkostlivě vyhýbáš)

hu

#29 hlucheucho

Proč z C++? Dyť to platí v obou jazycích.

Já vlastně globální proměnné nepoužívám vůbec takže nehrozí mílka. Pro mě je naopak někdy přehlednější dát tam stejný název proměnné - zoom - i když je to jiná proměnná. Proč? Protože aspoň vím co tam je za data. Ale až budu pokračovat v psaní hlavní funkce tak to můžu ještě doladit. Zatím je to tak provizorně, i když ty pointery (*s) nejsou moc přehledné

#28 KIIV

Jo tak ten pointer jsem tam zapomněl když jsem to měnil z char * na int ...

Že je post-inkrementace pomalejší jsem pochopitelně nevěděl a samozřejmě nevím proč to tak je

#30 oxidián
v c++ muzes definovat referenci jako treba:  int funkce(int & ref) { ... }  a  zavola se to jen   out = funkce(neco);

kdyz zmenis tu promennou ref, tak se zmeni i vne funkce.. zadny pitomy pointery.

A pomalejsi i++ je proto, ze to jeste musi vracet taky puvodni hodnotu.. neco jako   x > i++  tak se srovnava x s puvodni hodnotou i. Ta zvetsena se pak objevi az pote. Ale znamena to, ze se musi udelat kopie. U jednoduchych typu to jeste neni tak strasny, ale v c++, kdyz to udelas nad nejakym vetsim objektem, tak uz je pak hodne kopirovani.

#31 KIIV
Ok, pokusím se na to myslet a snad na to nezapomenu. Ono se taky člověku nechce všechno celé přepisovat.

Se ti ani nedivim, pises vsechno relativne write-only, upravovat v tom neco musi byt hotovy peklo.

Ja neco podobneho, jak popisujes nahore, resim vyplnenim vsech policek a pak zakazanim tech, ktere tam nechci. 

arr = [ ];
li = 64
for (i=0;i<li;++i) {arr[i] = i;}
zakazane = [9,54,6];
li = count(zakazane);
for (i=0;i<li;++i) {arr[zakazane[i]] = -1;}

V dalsim zpracovani mam potom ifko na >=0. To tve cislovani jine od normal integeru, mi nedava moc smysl. Preci, ikdyz mas

for (i=0; i<li; ++i)
for (j=0; i<lj; ++j) {...

Tak to muzes pridat k.

for (i=0,k=0; i<li; ++i)
for (j=0; i<lj; ++j,++k) {...

Trochu ten tvuj system pripomina quad-tree pouzivany pro kompresi cerno-bilych obrazku. Tam se udela tverec, ak se rozdeli na 4, pak kazda cast znovu na 4, dokud nebude v oblasti pouze jedna barva. 

	0.              1.		2.
	 ______		 ___ ___	 ___ _ _
	|      |	|a1 |a2 |	|   | | |b1 b2
	|   x  |	|   |x  | 	|    -o-
	|   x x|	|---o---| 	|   |x| |b3 b4
	|___x_x|        |a3 |x x|a4	|---o---
			|___|x_x|	|   |x x|
					|___|x_x|
                        uzel-a		uzel-b          
        Code 4x4
	1. o (uzel-a)
	2. W (ctverec a1 obsahuje pouze barvu W)
	3. o (uzel-b, ctverec a2 obsahuje barvy B a W)
	4. WWBW (ctverec b1,b2 - W, b3 - B, b4 - W)
	5. W (a3 - cely je v barve W, neni treba delit)
	6. B (a4)
	>> oWoWWBWWB

(2*3na8 = 13122, na bity 14 bitu, puvodni velikost 4x4 16 bitu)

#33 KIIV
Nevím co tím myslíš write only.

isdigit sice existuje, ale já využívám toho že posouvám ukazatel. Nejde jen o to zjistit jestli je to číslice, ale o to posouvat ukazatel tak dlouho dokud ukazuje na číslici. Nakonec volání funkce je pomalejší než inline kód.

for (;*(*s) != '\0' && (*(*s) == coordSep || ( *(*s) >= '0' && *(*s) <= '9')) ;++(*s)) { }

Dá se to v Céčku udělat, nastavit číslo o velikosti char:
w->task.temp.square_zooms[w->task.temp.square_no] pomocí pointeru na char? Použít proměnnou zoom jako prostředníka, nebo to taky nejde?

char * zoom = w->task.temp.square_zooms[w->task.temp.square_no]; zoom = atoi(*s); # tak toto nejde

#35 oxidián
Nakonec volání funkce je pomalejší než inline kód.

Překladač provádí optimalizaci, takže to nemusí být pravda.

Dá se to v Céčku udělat, nastavit číslo o velikosti char:

Musíš úzkostlivě šetřit pamětí?

hu

#34 peter
U mě ale jde o pravděpodobně velké množství čtverců takže to by nebylo efektivní. Já už vím jak to udělat, teď jsem však neměl chuť v tom pokračovat takže to vázne. Mě přijde geniální ta moje myšlenka s tím přiřadit každému čtverci který je definovaný v konfiguráku číslo podle jeho významu a podle toho větvit program co má dělat. To je při postupu z nejvyšší nadřazené úrovně po nejnižží.

Níže úvaha o opačném postupu odzdola nahoru (od detailu k celku):

Ale při opačném postupu od detailů k celku (dalo by se dobře využít například při analýze obrazu, kdy chceš detekovat nějaké tvary v obraze) bych postupoval metodou "Z" nahoru. Jako máš ten čtverec rozdělený na čtyři kvadranty:

1,2

3,4

Tak bys detekoval či analýzoval takto: 1,2,3,4 (čili Z).

A na další úroveň bys postupoval takto:

1,2 ; 5,6

3,4 ; 7,8

9,10;   13,14

11,12; 15,16

na další úroveň bys postupoval takto:

1,2 ;   5,6   ; 17,18 ; 21,22
3,4 ;   7,8   ; 19,20 ; 23,24 
9,10;   13,14 ; 25,26 ; 29,30
11,12;  15,16 ; 27,28 ; 31,32

33,34;  37,38 ; 49,50 ; 53,54
35,36;  39,40 ; 51,52 ; 55,56
41,42 ; 45,46 ; 57,58 ; 61,62 
43,44 ; 47,48 ; 59,60 ; 63,64

A tak dále až by ses dostal na nejvyšší úroveň. Podmínky pro analýzu by mohly být různé, například bych mohl hledat tmavě zelenou barvu v určitém rozsahu uvnitř čtverce 8x8px. Když čtverec obsahuje zelenou barvu tak vím že je tam určitý zelený objekt. Ještě by se dalo zase počítat s tím jestli je ten zelený pixel vlevo, vpravo, nahoře, dole či uprostřed analyzovaného čtverce. To proto, že pokud by onen tvar ležel na rozhraní dvou čtverců, tak by běžná podmínka nemusela stačit*. A chtěl bych spočítat kolik takových čtverců jsem našel, nebo v kterých místech se ty čtverce nachází a jaká je jejich celková hustota na obrázku (dalo by se třeba převést na grayscale mapu čtverců, kde intenzita barvy znamená množství výskytu, černá nic, bílá hodně). To jen taková úvaha. Tenhle mechanismus je v docela jednoduchý, ale realizace by zas zabrala čas...

Poznámka - dovysvětlím. Představ si, že máš obrázek s různými geometrickými tvary a někde mezi nimi leží tmavě zelený čtverec o velikosti 5x5px. Prozkoumával bych oblasti čtverců po 8x8px, ale pokud by ten čtverec ležel na rozhraní dvou tak ho normálně přehlédnu protože běžnou analýzou neuvidím velikost čtverce 5x5 ale třeba 2x5 vpravo v jedné oblasti a v sousední oblasti vedle bude 3x5... Máš tedy místo toho dva menší obdélníky. Pokud bych použil detailnější rozpoznávání tvarů tak do struktury mohu uložit že v dané oblasti vpravo jsem našel zelené pixely, které jsou menší než ona hledaná oblast, vlevo v sousední oblasti jsem našel taky nějaké zelené pixely, a jejich celková vzdálenost odpovídá velikosti čtverce, takže bych to vyhodnotil jako čtverec ležící mezi dvěma oblastmi.

Write only kod znamena ze clovek, kterej to po tobe bude cist, radeji spacha harakiri, nez by se to snazit pochopit, natoz opravit.

char * zoom = w->task.temp.square_zooms[w->task.temp.square_no];
       zoom = atoi(*s);

Cimpak to asi bude, ze to nefunguje. Mas promennou zoom typu pointer na char, a pak ten pointer prepises nejakym cislem (a jeste kdo vi, jestli je v te promenne pri inicializaci zrovna pointer na char).

Pokud chces prevest jeden znak na cislo, tak existuje    *(*s))-'0'  -> kdyz to bude cislo, tak je to 0-9

Pokud chces na pozici zoom zapsat jeden byte, tak musis ukladat na pozici, kam to ukazuje:  *zoom = ...

Kdyz uz chces porad tak trvat na predcasne optimalizaci (pricemz to pak stejne nejspis sejmes neoptimalnimi algoritmy), tak ten cyklus muze pouzit index do pole:  0-255, kde jen na pozicich '0' az '9' bude 1, pro pokracovani cyklu - bude tam jedine vyhodnoceni pro vsechny.

Write only kod má ještě jednu nevýhodu: když k tomu přijdeš s odstupem času, tak to harakiri spácháš sám

hu

w->task.temp.square_zooms:

0x3e29f0 "\rđ­ş\rđ­ş\rđ­ş\rđ­ş\rđ­ş\rđ­ş\rđ­şîţ\253\253\253\253\253\253\253\253îţ" (char *)

w->task.temp.square_no: 0 (int)

Čímpak to asi bude že to nefunguje? No já přece vím že je to špatně, ale ptám se na řešení jak nastavit ten bajt w->task.temp.square_zooms[0] na hodnotu vrácenou voláním atoi(*s) pomocí té proměnné zoom. (*zoom)= krachne

nefunguje proto, ze do toho pointeru nacpes data z konkretniho zooms[0]...

pokud chces adresu, tak bud:

zoom = &(w->task.temp.square_zooms[w->task.temp.square_no]);

nebo:

zoom = w->task.temp.square_zooms + w->task.temp.square_no;

Tak konečně je to funkční:

char * zoom = &(w->task.temp.square_zooms[w->task.temp.square_no]);
*zoom = atoi(*s);

díkes.

Pokud chces prevest jeden znak na cislo, tak existuje    *(*s))-'0'  -> kdyz to bude cislo, tak je to 0-9

Takže podmínka pro is_digit() by měla být takto?

*(*s))-'0'>=0

#43 oxidián
jen v pripade, ze to bude unsigned char, jinak to nebude fungovat

#44 KIIV
#40 oxidián
Je tam typ char*

Ještě zpětně dotaz k printf %.12s
Dostávám hlášku:

task file: incorrect separator follows zoom number:+G>
A nechápu kde se to tam vzalo. V celém souboru není písmeno G, a taky string začíná na # znak není následován tečkou. Nechápu ten printf proč to tam dává navíc mám pocit, že ta podmínka co si mi doporučil nedělá to co by měla. To ale bude tím že pokud je tam # tak musím podmínku přeskočit. Vysvětlení pro printf?

char * s;

*s = 0x3e472b "# Pro definici podčtverců v dané oblasti smíte pou\236ít jen + nebo jen -, nesmíte to střídat.\n"

char coordSep = '.'; 
if ( (*s)[1] == '\0' || (*s)[2] == '\0' || 
   !( (*s)[1] == coordSep ^ (*s)[2] == coordSep ) )
 { printf("task file: incorrect separator follows zoom number:%.12s\n",s);
 return -6; }

Mám takový neobvyklý problém s podmínkou if .. else ... Normálně když ladím tak mi to najde do obou větví místo do jedné. Jak je to možné? Separator je \0, skipChar je #. *s je #. Krokuju po jednom řádku a skočí mi to na 4. řádek, skip = true; další krok ale skočí do bloku else ... na řádek s funkcí blockDepthParser(w, &s, goOn);

    if (*s != separator)
        {
        if ( *s == skipChar ){
            skip = true;}
        else {


            if ( !skip ) {
            // The >dip> section is parsed only once (next chars are skipped till next dip is found)
            if ( *s == dip ) {
                inBlockDepth++;
                // prev  = s - 1;
                if ( *(s - 1) == '+')
                    type = 'i';
                else if ( *(s - 1) == '-')
                    type = 'e';
                if (*(s+1) > 35){
                    if ( *(s+1) < 'b' || *(s+1) > 't' ) {
                        printf("Incorrect character in task file: %.20s\n", s);
                        abort_parseTaskFile(w,s,-1);
                        }
                    else{
                        blockDepthParser(w, &s, goOn);
                        }
                    } // next char is not \0
              } // if dip found
            } // if !skip


            } // *s != skipChar
        } // parsing a line

Tak tu příčinu jsem našel. Bylo to tím že jsem definoval funkci inline ale v hlavičkovém souboru jsem při deklaraci vynechal slovo inline. Zdá se, že když jsem zmáčknul f7 (krok vpřed) tak to jelo jako f8 (continue to next breakpoint).

Edit: Kurňa, ještě to stále není ono.

                if (*(s+1) > 35){
                    if ( *(s+1) < 'b' || *(s+1) > 't' ) {
                        printf("Incorrect character in task file: %.20s\n", s);
                        abort_parseTaskFile(w,s,-1);
                        }
                    else {
                        blockDepthParser(w, &s, goOn);
                        }
                    printf("OH YES;");
                    } // next char is not \0

Když odstraním to printf("OH YES;"); tak to zase skočí do toho else na řádek s
blockDepthParser . Co to je???
 

Proč když *s je 3 , zoom = atoi(*s); dává 13 místo 3?

Připojen obrázek.

Zkouším zoom = (char) atoi(*s); a nic.

Zajimave, jak nekdo dokaze delat tak urputne stejny chyby do zblbnuti dokola a dokola a dokola....

char zoom = ....   mame jeden ZNAK

priradime do nej adresu neceho &(...) ... vysledek? Mame jeden bajt z adresy, ktery hned pote prepiseme jednim bajtem z vysledku atoi....

Jo no to už jsem vyřešil. Ale to je tím že já se to naučím až to budu psát po stopadesátpáté :-) Prostě opakuju ty samé chyby pořád dokola to se nedá si to vše hned zapamatovat.

Mozna by sis to mel zapisovat, a nez polozis otazku, tak projet poznamky, jestli se to uz neresilo.

Tvuj problem s pamatovanim je i rozsah "projektu", ktery je ocividne trochu moc velky sousto, kdyz se furt jeste ani nesnazis pochopit ty pointery.

Jinak k tomu pamatovani: treba vcera zrovna pomohlo k nalezeni jedny zahadny chyby to, co jsem slysel dva roky nazpet na jednom skoleni c++. Viz: http://www.hovnokod.cz/3010 - jde tam o to, ze se v te metode nastavuje zaroven velikost. Jenze autor pozapomnel, ze poradi zpracovani parametru neni definovano a zrovna g++ ho dela od zadu.

S takovymhle kopancem se clovek nesetka zase tak casto a hadam, ze tam moc +1 nedostanu :D

A pred par mesicema byl dotaz na nejakou chybu a hned mi bylo jasne, ze sem se asi pred 4rokama na to same ptal kolegy a odpovedi bylo, ze by tam melo byt nastaveni na zmenu toho chovani na pozadovane. A taky bylo.

Proste: kdyz pochopis co delas, tak se hned vse pamatuje lepe.