TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
Zdravim,
dostal za jsem úkol naprogramovat systém pro řízení databáze údajů v konzolové aplikaci. Program by měl zpracovávat údaje v jednotlivých tabulkách (založení tabulky, definice struktury záznamů, ..).
Vůbec si nedokážu představit, jak by to mělo vypadat. Bylo mi řečeno,že jako databáze v PhpMyAdmin, ale jak to udělat v konzolové aplikaci vážně nevim.
Poradí mi někdo? Děkuji
Konzolovou aplikací se myslí příkazový řádek? V tom případě mě napadají dvě možnosti. Buď udělat uživatelské rozhraní ve formě menu (něco jako "zmáčkni T pro vytvoření tabulky, V pro vložení dat atd."), to by bylo jednodušší, ale těžkopádnější na obsluhu. Nebo napsat interpret nějakého jazyka (třeba SQL nebo nějakého vlastního), to by bylo praktičtější, daly by se třeba spouštět předem připravené sady příkazů a líp by se to testovalo.
V pozadí by asi bylo několik souborů: jeden s definicemi tabulek a potom pro každou tabulku jeden datový soubor. Konkrétní implementace těch definic závisí na tom, jaké datové typy chceš používat (jestli nejsi masochista, radši pro začátek používej jenom typy s pevnou délkou).
Něco navrhni a pak přijď s konkrétnějšími otázkami, nějak to snad vyřešíme.
Normálně bych kouknul jak vypadá menu PhpMyAdmin a tomu bych navrhnul textovou alternativu s tím že vždycky budeš čekat na volbu od uživatele, co si vybere.
Jestli to chápu správně tak nebudeš řešit SQL příkazy, ale vytvářet / spravovat vlastní databázi? Resp dělat téhle databázi front-end pro správu.
V tom případě začni vymýšlením datových struktur. Čili jak vyjádříš, že tabulka má 8 sloupců, že první se jmenuje "id" a je to číslo, druhý je třeba "jmeno" a je to dvacetiznakový text a tak dále. Osobně bych si asi pro každý typ zavedl číselný kód, takže by pak informace o struktuře jedné tabulky bylo číslo udávající počet sloupců a potom pole (nejlépe dynamické, ale asi to nebude nutné), které by v každé položce mělo kód typu a název. Nějakou takovou definici tabulky si zatím nadeklaruj jenom jako konstantu, abys s tím mohl experimentovat, uživatelské definice můžeš dodělat později.
Potom si vymysli, jak budeš ukládat tabulky. Já bych si asi pro každou tabulku vyrobil jeden soubor, jeho jméno by odpovídalo jménu tabulky. Pro začátek by byl prázdný.
Potom vkládání dat do tabulky. Protože počet sloupců může být v každé tabulce jiný, asi budeš potřebovat, aby zadávací funkce procházela definici tabulky a postupně se ptala na požadovanou hodnotu každého sloupce. Soubor otevři pro čtení i zápis (viz Filemode a Reset), nastav se na konec (Seek, Filesize) a data do něj zapisuj (Blockwrite), jak je uživatel zadává. Délku k zapsání určíš podle svého typového kódu. Nakonec soubor zavři.
Dál už je to "jenom" postupné přidávání dalších funkcí ;-).
#1 blekota
Mno, ucitel nejspis chce, aby tvuj program umel SELECT, INSERT, UPDATE, DELETE. Cili zobrazit tabulku, pridat radek, smazat radek, upravit radek. Nic vic. jenze tihle informatici ti nic nereknou konkretne.
Takze si staci udelat typ record, priradit ho k promenne. Ovladaci rozhrani pres klavesnici. A pak programu.Nahodou tu mam kod jakehosi programu, ktery by mel slouzit pro vlozeni 20 radku a pak zobrazeni tabulky. Pozor, muze obsahovat chyby, je to opis nejakeho studenta z tabule doplneny o komentare.
Newbie
Nahlásit jako SPAM
IP: 46.13.48.–
Věrný člen
Super člen
--- RECORD.PAS ---
program zamestnanci;
uses crt;
type
tclovek=record {vytvor datovy typ, sloupce radku 'jmeno':string, 'prijmeni':string, 'plat':real
jmeno: string;
prijmeni: string;
plat: real;
End;
tpole= array [1..20] of tclovek; {vytvor datovy typ tabulku (pole) 1..20 radku obsahujicich sloupce podle tclovek}
{
cili tabulku:
['jmeno':'', 'prijmeni':'', 'plat':0],
['jmeno':'', 'prijmeni':'', 'plat':0],
['jmeno':'', 'prijmeni':'', 'plat':0],
... 20x (20 radku)
}
var
lide: tpole; {vytvor promennou "lide" typu "tpole" (definovaneho nahore)}
i: integer;
Begin
for i:=1 to 20 do {cyklus pro i=1 az i=20 (cili pro 20 radku)}
with lide[i] do
Begin
writeln ('napis jmeno'); {- vypis text}
readln (jmeno); {- nacti promennou jmeno, odbouchnute enterem}
writeln ('napis prijmeni'); {- vypis text}
readln (prijmeni); {- nacti promennou prijmeni, odbouchnute enterem}
writeln ('napis plat'); {- vypis text}
readln (plat); {- nacti promennou plat, odbouchnute enterem}
End;
for i:=1 to 20 do {cyklus pro i=1 az i=20 ... cili, zobraz prave ulozenou tabulku}
writeln (lide[i].jmeno:15,lide[i].prijmeni:15,lide[i].plat:10) {- vypis zaznam na radek}
{formatuj string jmeno na 15 znaku (formatuj plat na radku [i] ...) (cili jmeno delsi 15 znaku zkrati na 15 a mensi 15 znaku prodlouzi na 15)}
{formatuj string prijmeni na 15 znaku}
{formatuj cislo plat na 10 znaku}
{
tim se docili toho, ze tabulka nebude vypada jako v predeslem rozsypane
1 33 5 7 886 86 23
45 67 889 333 222 44
ale
tonda kucera 10000
helena ruzickova 120000
0123456789012345012345678901234501234567890 (pomocne meritko)
}
END.
#5 Mircosoft
Ano. Přesně takhle by to mělo vypadat. Bohužel na tohle nemám dovednosti ani zkušenosti. Dokážu nadeklarovat akorát tak jednorozměrné pole typu : (type
TPoleZnaku = array[byte] of char;
TPoleCisel = array[1..5] of integer;
TPoleLogic = array['A'..'Z'] of boolean;
TPoleReal = array[boolean] of real;) což je oproti tomu co jste popisoval dost chabé a nereálné:D
A informace o zavedení číselného kódu v poli slyším poprvé.
Každopádně děkuji za velmi detailné popsání
Jestli je to školní úkol, tak bys ty dovednosti touhle dobou už mít měl, ne? ;-)
S jednorozměrnými poli si vystačíš a pokud není výslovně zadáno, že tabulky mají mít dynamický počet sloupců, můžeš si prozatím zvolit nějaké rozumné maximum a přebytečné sloupce nechat nevyužité - tím se vyhneš dynamické alokaci paměti a podobným věcem.
Ty kódy typů jsem myslel nějak jako array of char, kde 'C' = číslo, 'T' = text a podobně. Prostě jenom něco, v čem by sis uložil informace o tom, jaké datové typy ve kterém sloupci máš. Ale pro začátek se na typy můžeme vykašlat a všechno brát jednotně jako text. Jediná nevýhoda by potom byla, kdyby zadávající chtěl, aby databáze uměla i aritmetické operace, ale i to by se dalo zvládnout (viz Val).
Zkusím příklad:
const MaxPocetSloupcu=10; {nebo jiná hodnota podle potřeby}
type tabulka=record
PocetSloupcu:integer; {skutečný počet sloupců, menší nebo rovný maximu}
jmena:array[1..maxpocetsloupcu] of string[20]; {seznam jmen sloupců, délka může být samozřejmě i jiná než 20}
end;
A další příklad, jak by to asi mohlo fungovat. Dejme tomu, že takhle:
Vyber funkci (Definice tabulky, Zadávání dat, Tisk, Konec): D
Zadej požadovaný počet sloupců: 2
Zadej jméno 1. sloupce: jmeno
Zadej jméno 2. sloupce: adresa
Tabulka vytvořena.
Vyber funkci (Definice tabulky, Zadávání dat, Tisk, Konec): Z
Zadej hodnotu sloupce jmeno: Pepa Novák
Zadej hodnotu sloupce adresa: Pod mostem 10, Lhota
Řádek vložen. Vložit další? A/N: A
Zadej hodnotu sloupce jmeno: Jarda Carda
Zadej hodnotu sloupce adresa: Chaloupka u lesa
Řádek vložen. Vložit další? A/N: N
Zadávání ukončeno.
Vyber funkci (Definice tabulky, Zadávání dat, Tisk, Konec): T
Výpis tabulky:
jmeno adresa
------------------------------------
Pepa Novák Pod mostem 10, Lhota
Jarda Carda Chaloupka u lesa
Vyber funkci (Definice tabulky, Zadávání dat, Tisk, Konec): K
Program končí.
Z toho už bys mohl dát dohromady aspoň prázdnou kostru programu, tj. hlavní cyklus s výběrem funkce. Definice tabulky snad taky nebude nijak extrémně těžká. Až to nepůjde dál, předveď aktuální zdroják a ptej se dál ;-).
Po dlouhé době se zase ozívám.
Definici tabulky jsem nejspíš vyřešil. Použil jsem tvojí deklaraci pole:
const MaxPocetSloupcu=10; {nebo jiná hodnota podle potřeby}
type tabulka=record
PocetSloupcu:integer; {skutečný počet sloupců, menší nebo rovný maximu}
jmena:array[1..maxpocetsloupcu] of string[20]; {seznam jmen sloupců, délka může být samozřejmě i jiná než 20}
end;
Následně jsem udělal deklaraci tabulky takto :
write('Zadejte nazev tabulky: ');
readln(databaz.nazev);
write('Zadej pocet sloupcu: ');
readln(databaz.pocetSloupcu);
for i:=1 to databaz.PocetSloupcu do
begin
Write('Zadej jmeno ',i,'. sloupce: ');
readln(databaz.jmena[i]);
end;
write('(Z)pet');
vyber:=upcase(readkey);
case vyber of
'z','Z' : goto jump_uvod;
end;
Ale teďkon nevím jak do té tabulky vkládat záznamy, aby byly záznamy pod nadefinovanými sloupci, jelikož tam nemám pevně daný sloupce jako např. ,,jméno" , ,,příjmení" , ale svoje vlastní názvy nikde nedeklarovaný.
Zkoušel jsem to takto, ale bezvýsledně :
for i:=1 to 10 do begin
write('Zadej hodnotu sloupce', databaz.jmena[i], ':');
readln(vloz);
write(vloz:10);
end;
writeln('Dalsi zaznam? (A/N)');
until upcase(readkey)<>'A';
Začátek vypadá docela slibně, jenom poněkud nechápu to "(Z)pet" a goto. Radši to napiš bez skákání, ať v tom později není guláš.
Vkládání hodnot máš skoro v pořádku, až na horní mez cyklu - musí jet do PocetSloupcu, ne do deseti.
Ukládat budeš muset rovnou do souboru (tedy jestli se nechceš patlat s dynamickými datovými strukturami v paměti). Protože ukládáš texty s obecnou (předem neznámou) délkou, nemůžeš jednoduše sesypat celý řádek tabulky do jednoho řádku souboru (leda že bys zavedl nějaké speciální znaky na oddělení jednotlivých sloupců a vyřešil čtení řádků delších než 255 znaků). Asi bych příkaz write(vloz:10) přepsal na writeln(soubor,vloz). Plus možná ještě před začátek cyklu zápis nějaké jednořádkové kontrolní hlavičky. A samozřejmě před tím otevření souboru Appendem a potom zavření Closem. Tím ti vznikne soubor, kde každý řádek tabulky zabere PocetSloupcu řádků, každý pro jeden sloupec.
No, a čtení databáze potom bude jednoduché Readln ve dvojitém cyklu - vnější while not eof, vnitřní for i:=1 to pocetsloupcu. Samozřejmě to znamená, že si musíš do nějakého dalšího souboru uložit tu definici tabulky, abys ji nemusel pokaždé znovu zadávat z klávesnice - třeba na první řádek počet sloupců a na další řádky jednotlivá jména. Načtení bude podobné jako zadání od uživatele, jenom se nebudeš na nic ptát a budeš to číst rovnou ze souboru.
Tak při vkládání záznamů si vytvořím soubor ,,zaznamy.txt,, a takhle vypadají záznamy v tom souboru:
Pepa
Novák
Jarda
Carda
Ale nějak se mi nedaří vytvořit soubor pro tu tabulku.
assign(t, 'tabulka.txt');
rewrite(t);
append(t);
write('Zadejte nazev tabulky: ');
readln(databaz.nazev);
write('Zadej pocet sloupcu: ');
readln(databaz.pocetSloupcu);
for i:=1 to databaz.PocetSloupcu do
begin
Write('Zadej jmeno ',i,'. sloupce: ');
readln(databaz.jmena[i]);
readln(zadani);
writeln(t,zadani);
end;
write('(Z)pet');
vyber:=upcase(readkey);
case vyber of
'z','Z' : goto jump_uvod;
end;
Ten výpis jsem udělal takto:
clrscr;
begin
reset(s, zadani);
while not eof(s) do
begin
for i:=1 to databaz.pocetSloupcu do;
readln(s, zadani);
end;
close(s)Jenom abych se zorientoval: jména sloupců tabulky chceš uložit tak, že v tom souboru bude na každém řádku jedno a nic dalšího k tomu, takže celkový počet zjistíš až podle konce souboru? Jestli jo, tak:
assign(t, 'tabulka.txt'); - OK
rewrite(t); - OK, tím se soubor otevře pro zápis od začátku.
append(t); - nesmysl, smaž.
write('Zadejte nazev tabulky: '); - OK
readln(databaz.nazev); - OK
write('Zadej pocet sloupcu: '); - OK
readln(databaz.pocetSloupcu); - OK
for i:=1 to databaz.PocetSloupcu do - OK
begin - OK
Write('Zadej jmeno ',i,'. sloupce: '); - OK
readln(databaz.jmena[i]); - OK za předpokladu, že to pole je dostatečně velké.
readln(zadani); - tohle smaž,
writeln(t,zadani); - tohle taky
a sem dej: writeln(t,databaz.jmena[i]); - tím se zadané jméno uloží do souboru.
end; - OK
write('(Z)pet');
vyber:=upcase(readkey);
case vyber of
'z','Z' : goto jump_uvod; - aargh! Nešlo by to bez goto? A mimochodem: malé z nemusíš testovat, protože už jsi ho stejně zvětšil Upcasem.
end;
A ten druhý kousek:
clrscr;
begin - tohle je asi zbytečné, smaž to.
reset(s, zadani); - smaž parametr zadani, to je nesmysl (doufám, že s je textový soubor).
- sem dej i:=0; - budeš to postupně zvětšovat, jak budeš načítat jednotlivé řádky.
while not eof(s) do - OK
begin
for i:=1 to databaz.pocetSloupcu do; - celý tenhle řádek smaž.
readln(s, zadani); - OK, tedy jestli Zadani je string. Tím se načetlo jedno jméno.
- sem dopiš následující dva řádky:
inc(i); - posuň se o sloupec dál (taky by šlo napsat i:=i+1).
databaz.jmena[i]:=zadani; - ulož načtené jméno.
end; - OK
- a sem připiš: databaz.pocetSloupcu:=i; - uložení zjištěného počtu sloupců.
close(s) - OK, ale doplň za to středník.
Tím máš jména sloupců načtená v poli, stačí je vypsat.
Soubor se vytvořil, ale zůstal prázdný, i když do něj v programu zapisuješ? To bude možná tím, že jsi ten soubor nezavřel, takže data zůstala někde v mezipaměti a nedostala se na disk. Zkus za tu ukládací část připsat Close, snad to pomůže.
Jestli ne, tak jsi do něj zkrátka nic nezapsal. Zkus si všechno, co píšeš do souboru, pro kontrolu vypisovat i na obrazovku, ať vidíš, kolikrát jsi kudy šel a co se dělo. Nebo vyzkoušej krokování.
Druhou otázku jsem nějak nepochopil. Na prolezení x položek pole, jejichž počet zjistíš až za běhu programu, jiná možnost než cyklus (nejlépe for) neexistuje. A v tom cyklu stačí vypsat jednotlivé položky.
Ano, ten close(s) to vyřešil. Nyní se do souboru zapisujou názvy sloupců v pohodě. Ale pořád se mi nedaří ty sloupce ani záznamy z těch 2 souborů vypsat.
Ten celkový výpis u mě vypadá takto:
jump_vypis:
clrscr;
reset(s);
i:=0;
while not eof(s) do
begin
readln(s, zadani);
inc(i); //posun o sloupec dál
databaz.jmena[i]:=zadani;
end;
databaz.pocetSloupcu:=i;
readln;
close(s);
reset(s);
readln(s);
readln(s);
while not Eof(s) do
begin
Readln(s, zadani); //vypsání záznamů
end;
close(s);
Nemůže to být tím, že soubor pro def. tabulky mám proměnnou ,,s,, a pro záznamy taky?
Znovuvyužití proměnné S není problém, jenom ji musíš po zavření prvního souboru příkazem Assign přesměrovat na ten druhý.
První část (načtení definice) vypadá provozuschopně, jenom to readln; na konci je zbytečné (čeká na zmáčknutí Enteru).
Druhá část je poněkud mimo, samotné readln ti nic nevypíše. Potřebuješ tohle:
1) Vypsat hlavičku tabulky. Tedy for i:=1 to databaz.pocetSloupcu do write(databaz.jmena[i]:šířka);.
2) Potom potřebuješ dvojitý cyklus. Vnější smyčka bude určitě while not eof(s), to máš dobře. V ní ale musí být ještě vnitřní smyčka for i:=1 to databaz.pocetSloupcu, protože po načtení x řádků souboru, které tvoří jeden řádek tabulky, musíš na obrazovce zalomit řádek. Tuhle vnitřní smyčku bys ještě mohl pojistit příkazem if eof(s) then break;, aby se nevypisovaly nesmysly, kdyby náhodou soubor skončil předčasně. Ale pro začátek to nebude nezbytně nutné.
3) Ve vnitřním cyklu načteš řádek ze souboru (readln(s,zadani);) a vypíšeš ho na obrazovku (write(zadani:šířka);). Po postupném načtení a vypsání celého řádku, tj. za koncem vnitřní smyčky, ale ještě uvnitř té vnější, na obrazovce odřádkuješ (writeln;).
Tak jména sloupců se již vypisují, ale záznamy ještě ne. Mělo by to být přesně jsi mi psal. A chtěl jsem se ještě zeptat, jak docílim toho, abych po vypnutí programu nemusel zadávat vše znova (od definice tabulky, až po vkládání nových záznamů)? Přece vždycky před čtením otevřu soubor, ve kterém jsou již záznamy, které by se měli jenom vypsat.
reset(s, 'zaznamy.txt');
readln(s);
readln(s);
while not Eof(s) do
begin
for i:=1 to databaz.pocetSloupcu do
begin
readln(s,zadani);
write(zadani:10);
end;
writeln;
end;
close(s);
Reset takhle nefunguje, přepiš to na assign(s,'zaznamy.txt'); reset(s);. Potom smaž ty dvě zbytečné readln(s); hned za tím a mělo by to být v pořádku.
Jediný způsob, jak něco uchovat po vypnutí programu, je uložit to do souboru a při příštím spuštění to zase načíst. Definici tabulky (jména a počet sloupců) už takhle uložené máš; jestli po tobě program chce nové zadání, je to jenom chyba logiky - uprav ho tak, aby nejdřív zkusil načíst minulou definici a až kdyby se to nepovedlo, řekl si o zadání nové.
Se záznamy v databázi už to tak jednoduše nepůjde, protože nevíš, kolik jich celkem bude a jestli se ti vůbec vejdou do paměti (mimochodem, jaký překladač vlastně používáš?). Zatím jsem si to představoval tak, že záznamy vůbec v paměti uchovávat nebudeš, necháš je na disku a načítat je budeš jenom dočasně po jednom v případě potřeby. Výhodou by byla univerzálnost (bezproblémová funkce bez ohledu na velikost paměti), nevýhodou relativní pomalost (hlavně s těmi textovými soubory, ve kterých se nedá rychle skákat příkazem Seek).
#20 Mircosoft
Tak jsem to přepsal, ale záznamy se pořád nevypisují. Nevypíše se prostě nic.
Zatím program píšu v Delphi 7 (konzolová aplikace), ale musím přejít na Turbo Pascal, kvůli grafice o který musim program doplnit (barva, fonty, velikost,...), která v Delphi nejdou.
Jinak jsem myslel, že po vypnutí a znova zapnutí programu se nechá struktura tabulky. Nově přidávající záznamy se budou moc přidávat na konec za předešlé a výpis všech záznamů na obrazovku. Pak bych dal uživateli možnost smazat soubor tabulka.txt nebo záznamy.txt a tím pádem založit novou ,,databázy."
Nevypíše se nic? V tom případě ukaž aktuální zdroják, jinak není šance na něco přijít.
Delphi? V tom případě odpadají starosti o paměť, omezení 64 KB na proměnnou a podobně, takže databázi teoreticky můžeš celou načíst do jednoho pole, zpracovávat v něm a na konci zase celou uložit do souboru.
V TP v textovém režimu můžeš individuálně měnit jenom barvy. Velikost písma jde změnit jedině pro celou obrazovku najednou, výběrem režimu s jiným počtem řádků a sloupců, ale určitě nemůžeš udělat třeba velký nadpis a pod ním menší text (leda ASCII artem). Font se dá změnit jenom vlastními prostředky (přímými povely grafické kartě). Pro plnohodnotnou grafiku bys musel do grafického režimu, se kterým je IMHO víc práce než užitku. V Delphi bys to měl jednodušší přes okénka a formuláře, jenom už by to potom nebyla konzolová aplikace. Upřímně řečeno, když vidím, na čem se teď zasekáváš, doporučoval bych zůstat v texťáku a nezdržovat se estetikou. Teprve až ti bude databáze fungovat, má cenu zkoušet nějaké hezčí rozhraní.
Proměnné v paměti se po vypnutí programu ztratí. Co je v souborech, to zůstane. Přidávání dalších záznamů do hotového souboru jde, prostě na otvírání nepoužiješ Rewrite, ale Append.
tady je celý kód :
program Databaze;
{$APPTYPE CONSOLE}
uses
crt32;
const MaxPocetSloupcu=10;
type tabulka=record
nazev: string[50];
pocetSloupcu:integer;
jmena:array[1..maxpocetsloupcu] of string[50];
end;
tradky = array[1..30] of integer;
label volba_menu, jump_konec, jump_uvod, volba_nwm, jump_deklarace, volba_zacatek, jump_pridavani, jump_vypis;
var i: integer;
vyber: char;
databaz: tabulka;{deklarace tabulky}
radky : tradky;
s : text;
t : text;
zadani,soubor,radek : string;
procedure vymazatTabulku; {vymaze aktualni soubor}
begin
clrscr;
assign(s, 'Tabulka.txt');
erase(s);
writeln('Soubor ',s,' byl smazan!');
end;
begin
//inicializace;
volba_zacatek:
clrscr;
gotoxy (37,10);
write ('DATABAZE');
gotoxy (19,12);
write ('(S)pustit (N)apoveda (K)onec');
gotoxy (29,15);
write ('Databaze');
gotoxy (32,16);
write (' 2012/2013');
gotoxy (32,17);
write (' verze 1.0');
volba_menu:
vyber := readkey;
case vyber of
'k' , 'K' : goto jump_konec;
's' , 'S' : goto jump_uvod;
else goto volba_menu;
end;
jump_uvod:
repeat
clrscr;
gotoxy (1,5);
volba_nwm:
vyber := readkey;
gotoxy (19,9);
writeln('*******************************');
gotoxy (20,10);
writeln('(Z)alozit databazovou tabulku');
gotoxy (20,11);
writeln('(P)ridavani zaznamu');
gotoxy (20,12);
writeln('(V)ypis tabulku');
gotoxy (20,13);
writeln('(U)prav zaznam');
gotoxy (20,14);
writeln('(S)maz zaznam');
gotoxy (20,15);
writeln('(x)Zpet');
gotoxy (19,16);
writeln('*******************************');
vyber:=upcase(readkey);
case vyber of
'z' , 'Z' : goto jump_deklarace;
'p' , 'P' : goto jump_pridavani;
'v' , 'V' : goto jump_vypis;
// 'u' , 'U' : goto jump_uprava;
//'s' , 'S' : goto;
'x' , 'X' : goto volba_zacatek;
end;
until vyber=chr(27);
readln;
jump_deklarace:
clrscr;
assign(s, 'tabulka.txt') ;
rewrite(s);
gotoxy (1,9);
write('Zadejte nazev tabulky: ');
readln(databaz.nazev);
write('Zadej pocet sloupcu: ');
readln(databaz.pocetSloupcu);
for i:=1 to databaz.PocetSloupcu do
begin
Write('Zadej jmeno ',i,'. sloupce: ');
readln(databaz.jmena[i]);
writeln(s,databaz.jmena[i]);
end;
close(s);
write('(Z)pet');
vyber:=upcase(readkey);
case vyber of
'z','Z' : goto jump_uvod;
end;
jump_pridavani:
begin
assign(s, 'zaznamy.txt');
rewrite(s);
append(s);
repeat
clrscr;
for i:=1 to databaz.pocetSloupcu do begin {generuje dotaz pomoci konstant}
write('Zadej hodnotu sloupce ' , databaz.jmena[i] , ':');
readln(zadani);
writeln(s,zadani);
end;
writeln('----------------------');
writeln('Dalsi zaznam? (A/N)');
until upcase(readkey)<>'A';
close(s);
goto jump_uvod;
end;
jump_vypis:
clrscr;
reset(s, 'tabulka.txt');
i:=0;
while not eof(s) do
begin
readln(s,zadani);
inc(i); //posun o sloupec dál
databaz.jmena[i]:=zadani;
end;
for i:=1 to databaz.pocetSloupcu do write(databaz.jmena[i]:10);
readln;
close(s);
assign(s, 'zaznamy.txt');
reset(s);
while not Eof(s) do
begin
for i:=1 to databaz.pocetSloupcu do
begin
readln(s,zadani);
write(zadani:10);
end;
writeln;
end;
close(s);
//jump_uprava;
//repeat
//clrscr;
//gotoxy (20,10);
//writeln('(S)mazat soubory ');
//gotoxy (20,11);
//writeln('(Z)pet');
//vyber:=upcase(readkey);
//case vyber of
// 'z' , 'Z' : goto jump_uvod;
// 's' , 'S' : goto jump_pridavani;
// end;
// until vyber=chr(27);
jump_konec:
clrscr;
end.
Neukamenuj mě za to
write('(Z)pet');
vyber:=upcase(readkey);
case vyber of
'z','Z' : goto jump_uvod;
ještě sem to neupravil.
Jinak kód je dost nepřehledný. Spousta věcí by šla přes procedury, ale to upravim až to budu nějak mít
Ohledně grafiky: jasně, Graph. Ale v ní jsou jenom funkce jako start a konec grafického režimu, vyplnění celé obrazovky nějakou barvou, kreslení bodů, čar, obdélníků, kruhů, elips a podobně a psaní textu libovolným fontem a velikostí. Není tam ovšem pár drobností jako třeba zadávání textu z klávesnice (nějaká obdoba Readln), blikající kurzor a tak. To by sis všechno musel dotvořit sám: čtení kláves přes Readkey, vypsání znaku na obrazovku, při zmáčknutí Backspacu přemáznutí posledního znaku obdélníkem v barvě pozadí a posun kurzoru zpátky, vykreslení kurzoru čárou nebo podtržítkem atd.. Kdybys chtěl, mám na tyhle věci hotovou sadu jednotek, ale je to v podstatě jenom emulace windowsí grafiky v TP - to v Delphi uděláš rovnou a prakticky bez práce.
A teď ke tvému zdrojáku.
Za goto tě neukamenuju, jenom naznačím, jak se dá pohodlně obejít bez něj:
var volba:(zacatek,konec,menu,napoveda,deklarace,pridavani,vypis);
...
volba:=zacatek;
repeat
case volba of
zacatek:begin
...sem dej to, co mas za navestim volba_zacatek, zaver predelej na:
case vyber of 'k','K':volba:=konec;
'n','N':volba:=napoveda;
else volba:=menu;
end;
end;
menu:begin
...to co mas v uvodu, nakonec tohle:
case vyber of 'z','Z':volba:=deklarace;
'p','P':volba:=pridavani;
...atd...
end;
end;
...atd...
until volba=konec;
Plus ještě doporučuji lépe využívat funkci Upcase, abys nemusel testovat velkou i malou variantu zadaného písmena.
Typ TRadky a proměnnou Radky poněkud nechápu. Co s polem třiceti čísel? Kdybys do toho chtěl ukládat obsah databáze, muselo by to být pole array[0..hodně] of string[přiměřeně]. K jednotlivým buňkám bys pak přistupoval přes jeden index, který by se vypočítal jako řádek*počet_sloupců+sloupec. To by předpokládalo počítat řádky a sloupce od nuly, jinak by se to muselo upravit na (řádek-1)*počet_sloupců+(sloupec-1). Ale dokud máš data jenom v souboru, tohle nebudeš potřebovat.
Procedura VymazatTabulku nebude fungovat, protože proměnnou typu text nemůžeš jen tak vypsat na obrazovku - je to blok informací o souboru určený pro operační systém, ne pro lidi, takže není čitelný. Správě by poslední příkaz měl být writeln('Soubor tabulka.txt byl smazan!');.
Zacatek: z praktického hlediska nevidím důvod, proč dělat takovéhle "předmenu", když by se odkaz na nápovědu, informace o verzi atd. daly zabudovat do hlavního menu o kousek dál. Ale chyba to není. Jenom to návěští volba_menu je tu dost nevhodné, protože když sem skočíš odjinud, nebudeš mít vypsanou nabídku kláves, které máš zmáčknout.
Uvod: tady už ses do těch skoků a cyklů pěkně zamotal. Když se zmáčkne Esc, program neskončí (jak každý uživatel očekává), ale počká na stisk Enteru (jedno zbloudilé readln;) a pak pokračuje odstavcem jump_deklarace. Až to všechno předěláš na cyklus s casem uvnitř, tyhle problémy zmizí.
Deklarace: já osobně bych si to rozdělil na dvě samostatné části: zadávání z klávesnice do proměnné Databaz a následné kompletní uložení této proměnné do souboru. Ale je to jenom věc vkusu, fungovat to bude i takhle. Zbytek víceméně v pořádku, jenom když už si necháš zadat název databáze, měl bys ho taky uložit, aby příště tabulka nebyla bezejmenná. Nebo ještě lépe: zadané jméno tabulky použít jako jméno souborů pro databázi. Tím bys mohl mít několik databází zároveň. Uživatel by třeba zadal jméno "houby" a ty bys definici tabulky uložil do souboru například "houby.tab" a data do "houby.dat" (koncovky samozřejmě libovolné, jenom je potřeba nějak odlišit definici od dat).
Pridavani: vyhoď příkaz rewrite(s);, jinak si obsah souboru pokaždé zase smažeš. Komentář "generuje dotaz pomoci konstant" nechápu, ale to nevadí, na program nemá vliv. Zbytek vypadá v pořádku.
Vypis: tady je to nějaké pomotané. Definici tabulky (proměnná Databaz) máš přece hotovou, tak proč ji znovu načítáš? Načtení bude potřeba oddělit a hodit pod samostatný příkaz menu "načtení definice tabulky" (takže budeš mít dvě možnosti: buď načíst existující definici nebo vytvořit novou). Potom je ve výpisu potenciální problém: zarovnáváš to na šířku 10, ale jména mají deklarovanou délku 50. Takže když někdo zadá jméno delší než 10 znaků, zarovnání ti rozhodí. Takže uprav obě čísla na stejnou hodnotu, třeba 25 (ty se vejdou na obrazovku tři vedle sebe; kdyby jich bylo víc, musel bys vyřešit scrollování do stran). Podobně pro délku dat. Potom zruš to zbloudilé readln; hned za výpisem sloupců. Čtení a zobrazování dat je v pořádku.
Takže odstranil jsem skoky a upravil jsem to podle vaší předlohy(dost to zpřehlednilo program)
TRadky jsem odstranil ( tato deklarace mi zůstala, když jsem zkoušel jinou deklaraci).
Procedura VymazatTabulku již funguje (nehlásí žádnou chybu) a rovnou sem to rozšířil i na odstranění záznamů
U deklarace jsem upravil aby se ukládalo i jméno do souboru tabulka.txt. S tím, aby jméno tabulky uložilo jako jméno souboru je úžasný nápad, ale pro mě asi moc nereálný.
Program vypadá takto
program Databaze;
{$APPTYPE CONSOLE}
uses
crt32;
const MaxPocetSloupcu=10;
type tabulka=record
nazev: string[50];
pocetSloupcu:integer;
jmena:array[1..maxpocetsloupcu] of string[50];
end;
var volba: (menu,Sdef,Szazn,uprava,nabidka,konec,uvod,nwm,deklarace,zacatek,pridavani,vypis, napoveda);
i: integer;
vyber: char;
databaz: tabulka; //deklarace tabulky
s : text;
t : text;
zadani,soubor,radek : string;
procedure vymazatTabulku; //vymaze soubor
begin
clrscr;
assign(s, 'Tabulka.txt');
erase(s);
writeln('Soubor tabulka.txt byl smazan!');
end;
procedure vymazatZaznamy;
begin
clrscr;
assign(s, 'zaznamy.txt');
erase(s);
writeln('Soubor zaznamy.txt byl smazan')
end;
procedure KonecProgramu;
begin
clrscr;
end;
begin
//inicializace;
volba:=zacatek;
repeat
case volba of
zacatek:
begin
clrscr;
gotoxy (37,10);
write ('DATABAZE');
gotoxy (19,12);
write ('(S)pustit (N)apoveda (K)onec');
gotoxy (29,15);
write ('Databaze ');
gotoxy (32,16);
write (' 2012/2013');
gotoxy (32,17);
write (' verze 1.0');
case vyber of
'k' , 'K' : volba:=konec;
'n' , 'N' : volba:=napoveda;
else volba:=menu;
end;
end;
menu:
begin
clrscr;
gotoxy (1,5);
volba_nwm:
vyber := readkey;
gotoxy (19,9);
writeln('*******************************');
gotoxy (20,10);
writeln('(Z)alozit databazovou tabulku');
gotoxy (20,11);
writeln('(P)ridavani zaznamu');
gotoxy (20,12);
writeln('(N)acteni definice tabulky');
gotoxy (20,13);
writeln('(V)ypis tabulku');
gotoxy (20,14);
writeln('(U)prav zaznam');
gotoxy (20,15);
writeln('(S)maz zaznam');
gotoxy (20,16);
writeln('(x)Zpet');
gotoxy (20,17);
writeln('(K)onec');
gotoxy (20,18);
writeln('*******************************');
case vyber of 'z' , 'Z' : volba:=deklarace;
'p' , 'P' : volba:=pridavani;
'v' , 'V' : volba:=vypis;
//'n','N' : volba:=ndt;
'u' , 'U' : volba:=uprava;
//'s' , 'S' : volba:=;
'x' , 'X' : volba:=zacatek;
'k' , 'K' : volba:=konec;
end;
end;
deklarace:
begin
clrscr;
assign(s, 'tabulka.txt') ;
rewrite(s);
gotoxy (1,9);
write('Zadejte nazev tabulky: ');
readln(s,databaz.nazev); //zapisuje nazev tabulky do
//souboru tabulka.txt
write('Zadej pocet sloupcu: ');
readln(databaz.pocetSloupcu);
for i:=1 to databaz.PocetSloupcu do
begin
Write('Zadej jmeno ',i,'. sloupce: ');
readln(databaz.jmena[i]);
writeln(s,databaz.jmena[i]);
end;
close(s);
write('(Z)pet');
case vyber of 'z','Z' : volba:=menu;
end;
end;
pridavani:
begin
assign(s, 'zaznamy.txt');
append(s);
repeat
clrscr;
for i:=1 to databaz.pocetSloupcu do
begin {generuje dotaz pomoci konstant}
write('Zadej hodnotu sloupce ' , databaz.jmena[i] , ':');
readln(zadani);
writeln(s,zadani);
end;
writeln('----------------------');
writeln('Dalsi zaznam? (A/N)');
until upcase(readkey)<>'A';
close(s);
case vyber of 'z','Z' : volba:=menu;
end;
end;
vypis:
begin
clrscr;
reset(s, 'tabulka.txt');
i:=0;
while not eof(s) do
begin
readln(s,zadani);
inc(i); //posun o sloupec dál
databaz.jmena[i]:=zadani;
end;
for i:=1 to databaz.pocetSloupcu do write(databaz.jmena[i]:25); //upravena sirka na 25
close(s);
assign(s, 'zaznamy.txt');
reset(s);
while not Eof(s) do
begin
for i:=1 to databaz.pocetSloupcu do
begin
readln(s,zadani);
write(zadani:25); //upravena sirka na 25
end;
writeln;
end;
close(s);
end;
uprava:
begin
clrscr;
gotoxy (20,10);
writeln('(S)mazat soubory ');
gotoxy (20,11);
writeln('(Z)pet');
case vyber of 'z','Z' : volba:=menu;
's','S' : volba:=nabidka;
end;
end;
nabidka:
begin
gotoxy (20,10);
writeln('(S)mazat definici tabulky ');
gotoxy (20,11);
writeln('(O)dstranit soubor zaznamu ');
gotoxy (20,12);
writeln('(Z)pet');
case vyber of 's','S' : volba:=Sdef;
'o','O' : volba:=Szazn;
'z','Z' : volba:=uprava;
end;
end;
Sdef:
begin
vymazatTabulku;
end;
Szazn:
begin
vymazatZaznamy;
end;
konec:
begin
KonecProgramu;
end;
until volba=konec;
end;
end.
Ale s tim výpisem pořád bojuju. To znovu načtení jsem smazal a upravil takto
begin
clrscr;
reset(s, 'tabulka.txt');
i:=0;
while not eof(s) do
for i:=1 to databaz.pocetSloupcu do write(databaz.jmena[i]:25); //upravena sirka na 25
close(s);
assign(s, 'zaznamy.txt');
reset(s);
while not Eof(s) do
begin
for i:=1 to databaz.pocetSloupcu do
begin
readln(s,zadani);
write(zadani:25); //upravena sirka na 25
end;
writeln;
end;
Ale program ani neodladim, protože mi někde chybí END, ale vážně nevim kde.
1. google.com = pspad
2. stahni, nainstaluj, spust
3. soubor, novy, objekt pascal, ctrl+v (vlozit kod)
4. klikni na begin a ukaze/obarvi ti jeho end
Treba v druhem kodu mas while - begin - for - begin - end - end. Ok. Ale pak ti schazi end tedy pro begin na zacatku couboru, jak je tam clrscr;
To bude asi tím, že ta druhá část není celý program :-).
#26 blekota:
Ještě jednou mi vyknou a začnu jim onikat :-D.
Před nastavení nové Volby podle stisknuté klávesy musíš dát vyber:=readkey, jinak ti program rovnou skočí podle minule nastavené hodnoty Vyberu. To by způsobilo zaseknutí programu v nekonečné smyčce mezi obrazovkami Zacatek a Menu.
Část Konec se ti vůbec neprovede. Příkaz case nechá proběhnout vždycky jenom jednu větev, v tomhle případě nějakou, která nastaví volba:=konec, a než ho ten cyklus spustí znovu, ukončí ho podmínka until volba=konec. Zatím to sice nevadí, protožeKonecProgramu v podstatě nic nedělá, ale jestli do ní později dopíšeš nějaký důležitý "závěrečný úklid", budeš to muset upravit. Napadají mě dvě řešení. První: konec si rozdělit na dvě fáze, třeba konec1 a konec2. Menu po stisknutí K nastaví volba:=konec1. Odstavec Konec v hlavním case se změní na Konec1 a po provedení úklidu nastaví volba:=konec2. A ukončovací podmínka hlavního cyklu se změní na until volba=konec2. Nebo druhé možné řešení: hlavní cyklus udělat nekonečný (until false) a v odstavci Konec použít Break, který z cyklu vyskočí.
Ve výpisu máš pořád ještě špatně ten úvodní reset, se souborem tabulka.txt musíš proměnnou S propojit assignem, stejně jako to děláš o pár řádků níž. Plus pár chybiček od minula, o kterých už jsem jednou psal. Upravený výpis je o fous lepší, ale ještě potřebuje pár dalších úprav: smaž reset tabulky, i:=0, while a close, nech jenom ten for. Výpis záznamů je OK.
Mimochodem, zatím je ten kód nezkompilovatelný. Kromě toho divokého resetu ti tam zůstalo ještě zapomenuté návěští volba_nwm. Není od věci číst chybové hlášky překladače a přemýšlet, co asi znamenají. Nevím jak v Delphi, ale v TP to docela pomáhá.
Tak end jsem vyřešil 
Chyběl na konci před příkazem until.
Zato celý program se mi nějak povedlo zacyklit. Když program spustim a dám založit tabulku, tak vše proběhne ok, ale když dám volbu zpět, tak se mi to znova hodí na novou definici tabulky. Dále když mám menu a stisknu zpět tak problikne uvod, ale vrátí se hned do menu.
A perla na závěr. Když program úplně vypnu a znova zapnu, tak se mi rovnou spustí menu. Jestli jsem udělal chybu v tom, vyber := readkey nevim, ale jiná chyba mě nenapadá. Navíc, když u tý tabulky dám zpět (tlačítko z), tak u něj mám přiřazený menu: a né znova deklaraci tabulky.
Přikládám kód:
var volba: (zacatek,menu,deklarace,pridavani,vypis,uprava,nabidka,Sdef,Szazn,konec,uvod, napoveda);
i: integer;
vyber: char;
databaz: tabulka; //deklarace tabulky
s : text;
zadani : string;
begin
volba:=zacatek;
repeat
case volba of
zacatek:
begin
clrscr;
gotoxy (37,10);
write ('DATABAZE');
gotoxy (19,12);
write ('(S)pustit (N)apoveda (K)onec');
gotoxy (29,15);
write ('Databaze ');
gotoxy (32,16);
write (' 2012/2013');
gotoxy (32,17);
write (' verze 1.0');
vyber:=readkey;
case vyber of
'k' , 'K' : volba:=konec;
'n' , 'N' : volba:=napoveda;
else volba:=menu;
end;
end;
menu:
begin
clrscr;
gotoxy (19,9);
writeln('*******************************');
gotoxy (20,10);
writeln('(Z)alozit databazovou tabulku');
gotoxy (20,11);
writeln('(P)ridavani zaznamu');
gotoxy (20,12);
writeln('(N)acteni definice tabulky');
gotoxy (20,13);
writeln('(V)ypis tabulku');
gotoxy (20,14);
writeln('(U)prav zaznam');
gotoxy (20,15);
writeln('(S)maz zaznam');
gotoxy (20,16);
writeln('(x)Zpet');
gotoxy (20,17);
writeln('(K)onec');
gotoxy (20,18);
writeln('*******************************');
vyber:=readkey;
case vyber of 'z' , 'Z' : volba:=deklarace;
'p' , 'P' : volba:=pridavani;
'v' , 'V' : volba:=vypis;
//'n','N' : volba:=ndt;
'u' , 'U' : volba:=uprava;
//'s' , 'S' : volba:=;
'x' , 'X' : volba:=zacatek;
'k' , 'K' : volba:=konec;
end;
end;
deklarace:
begin
clrscr;
assign(s, 'tabulka.txt') ;
rewrite(s);
gotoxy (1,9);
write('Zadejte nazev tabulky: ');
readln(databaz.nazev); //zapisuje nazev tabulky do
writeln(s, databaz.nazev); //souboru tabulka.txt
write('Zadej pocet sloupcu: ');
readln(databaz.pocetSloupcu);
for i:=1 to databaz.PocetSloupcu do
begin
Write('Zadej jmeno ',i,'. sloupce: ');
readln(databaz.jmena[i]);
writeln(s,databaz.jmena[i]);
end;
close(s);
write('(Z)pet');
vyber:=readkey;
case vyber of 'z','Z' : volba:=menu;
end;
end;
pridavani:
begin
assign(s, 'zaznamy.txt');
append(s);
repeat
clrscr;
for i:=1 to databaz.pocetSloupcu do
begin {generuje dotaz pomoci konstant}
write('Zadej hodnotu sloupce ' , databaz.jmena[i] , ':');
readln(zadani);
writeln(s,zadani);
end;
writeln('----------------------');
writeln('Dalsi zaznam? (A/N)');
until upcase(readkey)<>'A';
close(s);
vyber:=readkey;
case vyber of 'z','Z' : volba:=menu;
end;
end;
vypis:
begin
clrscr;
assign(s, 'tabulka.txt');
for i:=1 to databaz.pocetSloupcu do write(databaz.jmena[i]:25); //upravena sirka na 25
assign(s, 'zaznamy.txt');
while not Eof(s) do
begin
for i:=1 to databaz.pocetSloupcu do
begin
readln(s,zadani);
write(zadani:25); //upravena sirka na 25
end;
writeln;
end;
close(s);
end;
uprava:
begin
clrscr;
gotoxy (20,10);
writeln('(S)mazat soubory ');
gotoxy (20,11);
writeln('(Z)pet');
vyber:=readkey;
case vyber of 'z','Z' : volba:=menu;
's','S' : volba:=nabidka;
end;
end;
nabidka:
begin
gotoxy (20,10);
writeln('(S)mazat definici tabulky ');
gotoxy (20,11);
writeln('(O)dstranit soubor zaznamu ');
gotoxy (20,12);
writeln('(Z)pet');
vyber:=readkey;
case vyber of 's','S' : volba:=Sdef;
'o','O' : volba:=Szazn;
'z','Z' : volba:=uprava;
end;
end;
Sdef:
begin
vymazatTabulku;
end;
Szazn:
begin
vymazatZaznamy;
end;
konec:
begin
KonecProgramu;
end;
end;
until volba=konec;
end.
#29 blekota
Říkají ti něco pojmy ladění,krokování, výpis obsahu proměnných (debug, step, watch)?
Pokud ne, měl by ses začít zajímat, složitější programy se bez toho psát nedají.
Takže když se ti něco "zacyklí", tak to krokuj, vypisuj si obsahy řídících proměnných a musíš na tu chybu přijít raz, dva...
Zjistit počet nových příspěvků
Ano, opravdu chci reagovat → zobrazí formulář pro přidání příspěvku
© 2003–2024 Programujte.com