Your SlideShare is downloading. ×
Niniejszy darmowy ebook zawiera fragment
                            pełnej wersji pod tytułem:
                       quo...
SPIS TREŚCI

Rozdział 8. Tablice.............................................................................5
  Deklarowa...
Rozdział 15. Zmienne dynamiczne.................................................220
  Wprowadzenie...........................
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
                                          ...
POLECAMY TAKŻE PORADNIKI:

Sekrety języka C# (c-sharp) – Andrzej Stefańczyk

                   Dlaczego tworzenie aplikac...
Programuję w Delphi i C++ Builder - cz.2
Upcoming SlideShare
Loading in...5
×

Programuję w Delphi i C++ Builder - cz.2

1,390

Published on

Jak szybko poznać elementy programowania w tych dwóch językach? (dla bardziej zaawansowanych)

Standardową metodą jest uczenie się programowania "język po języku". A co powiesz na dwa w jednym? Co gdybyś przy okazji zagłębiania się w szczegóły danej instrukcji w Delphi dowiedział się od razu, jak to samo robi się w C++ Builderze?

Te dwa środowiska programistyczne dominują teraz w firmach, to w nich powstaje większość spersonalizowanych aplikacji bazodanowych dla małych i średnich przedsiębiorstw.
Jak łatwo budować aplikacje o normalnym
("windowsowym") wyglądzie?

Napisałeś kiedyś program, który działał w konsoli? Byłeś dumny ze swojego dzieła, a jednak znajomi nie potrafili docenić piękna tekstowego interfejsu?

Odkryj coś, co pozwoli Ci w łatwy sposób budować aplikacje wyglądające, jak profesjonalne programy pod Windows... Delphi i C++ Builder to 32 bitowe, w pełni obiektowe, zintegrowane środowiska RAD (ang. Rapid Application Development) do szybkiego tworzenia aplikacji w systemie operacyjnym Windows.

Ta książka odkryje przed Tobą bardziej zaawansowane techniki pisania programów w Delphi i C++ Builderze. Jeśli dopiero zaczynasz programować, zapoznaj się z jej pierwszą częścią, która jest dostępna tutaj.

Dzięki zaznaczeniu kolorem fragmentów dotyczących danego języka programowania, a także zrzutom z ekranu, będziesz miał cały czas pewność, że wiesz, o co chodzi.
Co znajdziesz w tym ebooku?

(Poprzednie rozdziały znajdziesz w pierwszej części książki. Aby dowiedzieć się więcej na jej temat, kliknij tutaj.)

* Tablice. W rozdziale dowiemy się w jaki sposób deklarujemy tablice jedno- i dwuwymiarowe, na czym polega sor­towanie bąbelkowe oraz o tym, że tablice przechowują nie tylko licz­by, ale również teksty.
* Podprogramy. W rozdziale dowiemy się co to są pod­programy i do czego można je wykorzystać, jak definiujemy proce­dury i funkcje, jak przekazujemy informacje procedurom i funkcjom, co to są zmienne globalne i lokalne oraz co to jest rekurencja.
* Elementy grafiki. W rozdziale nauczymy się pisać proste programy graficzne w Delphi i C++ Builder oraz przed­stawimy graficzny przykład programu rekurencyjnego.
* Przechowywanie informacji w rekordach i w strukturach. Rozdział zawiera informacje o rekordach i struk­turach oraz w jaki sposób te informacje są przechowywane w języku Delphi i C++ Builder.
* Elementy programowania obiektowego. W rozdziale poznamy elementy programowania obiektowego, na­uczymy się pisać proste programy zawierające obiekty oraz dowiemy się na czym polega hermetyzacja danych, dziedziczenie i polimor­fizm.
* Operacje wejścia/wyjścia - część II. Pliki. W rozdziale opowiemy co to są pliki oraz dowiemy się jak zapisywać in­formacje do pliku i jak je odczytywać.
* Wskaźniki. Ten rozdział przybliży nam zawiłości wskaźników oraz poznamy w nim sposoby przekazywania parametrów przez wskaźnik i przez referencję.
* Zmienne dynamiczne. W rozdziale omówiono różnicę pomiędzy zmiennymi statycznymi a zmiennymi dynamicz­nymi oraz jak przydzielać i zwalniać pamięć dla zmiennych dynamicznych.
* Algorytmy numeryczne. W rozdziale omówiono kilka wybranych algorytmów numerycznych.

Uwaga! Powyższe rozdziały to nie wszystko - jest jeszcze dodatek. Zobacz, co zawiera:
D1. Formatowanie łańcuchów tekstowych
D2. Wybrane systemowe procedury konwersji typu
D3. Standardowe procedury obsługujące pliki (Delphi)
D4. Wyświetlanie komunikatów
D5. Wartości parametru Flags dotyczące liczby i rodzaju przycisków
D6. Grafika w Delphi i w C++ Builder
"Umiejętność pisania programów w różnych językach programowania, to wyzwanie dzisiejszych czasów adresowane
do młodych programistów."

O autorze:

Mirosław J. Kubiak jest absolwentem Uniwersytetu Mikołaja Kopernika w Toruniu, na którym ukończył fizykę. Obecnie pracuje jako nauczyciel informatyki

Published in: Education
1 Comment
0 Likes
Statistics
Notes
  • Aby pobrać ebooka na dysk twardy kliknij prawym przyciskiem myszy na 'Get File' (znajduje się nad ekranem ebooka), a następnie 'zapisz element docelowy jako...'

    Więcej informacji o Tym ebooku znajdziesz na stronie:
    http://zlotemysli.pl/lukas,1/publication/show/6304/Programuje-w-Delphi-i-C-Builder.html

    Darmowe materiały na temat rozwoju osobistego, NLP, motywacji, szybkiej nauki i wielu innych znajdziesz na stronie: www.Sukces.webnode.com
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • Be the first to like this

No Downloads
Views
Total Views
1,390
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
30
Comments
1
Likes
0
Embeds 0
No embeds

No notes for slide

Transcript of "Programuję w Delphi i C++ Builder - cz.2"

  1. 1. Niniejszy darmowy ebook zawiera fragment pełnej wersji pod tytułem: quot;Programuję w Delphi i C++ Builderquot; Aby przeczytać informacje o pełnej wersji, kliknij tutaj. Darmowa publikacja dostarczona przez Sukces.webnode.com Niniejsza publikacja może być kopiowana, oraz dowolnie rozprowadzana tylko i wyłącznie w formie dostarczonej przez Wydawcę. Zabronione są jakiekolwiek zmiany w zawartości publikacji bez pisemnej zgody wydawcy. Zabrania się jej odsprzedaży, zgodnie z regulaminem Wydawnictwa Złote Myśli. © Copyright for Polish edition by ZloteMysli.pl Data: 25.10.2006 Tytuł: Programuję w Delphi i C++ Builder (fragment utworu) Autor: Mirosław J. Kubiak Projekt okładki: Marzena Osuchowicz Korekta: Sylwia Fortuna Skład: Anna Popis-Witkowska Internetowe Wydawnictwo Złote Myśli Netina Sp. z o. o. ul. Daszyńskiego 5 44-100 Gliwice WWW: www.ZloteMysli.pl EMAIL: kontakt@zlotemysli.pl Wszelkie prawa zastrzeżone. All rights reserved.
  2. 2. SPIS TREŚCI Rozdział 8. Tablice.............................................................................5 Deklarowanie tablic.............................................................................................5 Dostęp do elementów tablicy.............................................................................11 Sito Eratostenesa...............................................................................................14 Tablice dwuwymiarowe.....................................................................................17 Sortowanie bąbelkowe.......................................................................................23 Tablice przechowują również teksty.................................................................28 Warto zapamiętać..............................................................................................42 Rozdział 9. Podprogramy.................................................................43 Co to są podprogramy.......................................................................................43 Definiujemy funkcje i procedury w języku Delphi...........................................43 Definiujemy funkcje w języku C++ Builder......................................................48 Programy mogą przekazywać podprogramom informacje..............................52 Przekazywanie parametrów przez wartość.......................................................54 Zmienne globalne i lokalne...............................................................................58 Przekazujemy funkcjom i procedurom tablice.................................................59 Rekurencja.........................................................................................................68 Warto zapamiętać..............................................................................................75 Rozdział 10. Elementy grafiki...........................................................76 Wprowadzenie ..................................................................................................76 Program Przykładowa grafika...........................................................................85 Graficzny przykład programu rekurencyjnego.................................................92 Warto zapamiętać............................................................................................110 Rozdział 11. Przechowywanie informacji w rekordach i w strukturach................................................................................111 Rekordy i struktury...........................................................................................111 Warto zapamiętać............................................................................................123 Rozdział 11. Elementy programowania obiektowego......................124 Wprowadzenie.................................................................................................124 Hermetyzacja danych.......................................................................................147 Dziedziczenie....................................................................................................147 Polimorfizm......................................................................................................158 Rozdział 13. Operacje wejścia/wyjścia – część II. Pliki...................160 Wprowadzenie.................................................................................................160 C++ Builder......................................................................................................162 Pliki tekstowe...................................................................................................163 Zapisywanie rekordów i struktur do pliku......................................................182 C++ Builder......................................................................................................191 Warto zapamiętać...........................................................................................200 Rozdział 14. Wskaźniki..................................................................202 Wprowadzenie.................................................................................................202 Wskaźniki i tablice...........................................................................................207 Programy mogą przekazywać podprogramom informacje – ciąg dalszy......213 Przekazywanie parametrów przez wskaźnik...................................................214 Przekazywanie parametrów przez referencję..................................................217 Warto zapamiętać............................................................................................219
  3. 3. Rozdział 15. Zmienne dynamiczne.................................................220 Wprowadzenie.................................................................................................220 Zmienne dynamiczne do tablic.......................................................................225 Klasy TStrings i TStringList............................................................................228 Warto zapamiętać...........................................................................................230 Rozdział 16. Algorytmy numeryczne..............................................232 Obliczanie sumy szeregu ................................................................................232 Wyznaczenie miejsca zerowego funkcji metodą Newtona.............................237 Wyznaczanie miejsca zerowego funkcji .........................................................244 Obliczanie całki metodą prostokątów.............................................................249 Dodatek.........................................................................................256 D1. Formatowanie łańcuchów tekstowych.....................................................256 D2. Wybrane systemowe procedury konwersji typu......................................258 D3. Standardowe procedury obsługujące pliki (Delphi) ..............................260 D4. Wyświetlanie komunikatów.....................................................................263 D5. Wartości parametru Flags dotyczące liczby i rodzaju przycisków..........264 D6. Grafika w Delphi i w C++ Builder............................................................268 Bibliografia....................................................................................272
  4. 4. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 5 Mirosław J. Kubiak Rozdział 8. Tablice W tym rozdziale dowiemy się, w jaki sposób deklarujemy tablice jedno- i dwuwymiarowe, na czym polega sortowanie bąbelkowe oraz o tym, że tablice przechowują nie tylko liczby, ale również teksty. Deklarowanie tablic Tablica jest to struktura danych, która umożliwia przechowywanie w sposób zorganizowany wielu zmiennych tego samego typu (całkowitego, rzeczywistego itd.). Aby stworzyć taką strukturę musimy dokonać deklaracji tablicy. W deklaracji tablicy musimy określić typ wartości, jaki ma przechowywać tablica, a także liczbę jej elementów. Tablice mogą być jednowymiarowe, dwuwymiarowe itd. Delphi Oto ogólna postać deklarowania w języku Delphi tablicy jednowymiarowej i związanej z nią zmiennej. type dentyfikator_tablicy = array[rozmiar_tablicy] of typ var nazwa_zmiennej : identyfikator_tablicy; Copyright by Złote Myśli & Mirosław J. Kubiak
  5. 5. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 6 Mirosław J. Kubiak A oto przykład zadeklarowania tablicy jednowymiarowej o nazwie dane typu całkowitego, zawierającej 10 elementów. type tablica = array[1..10] of integer; var dane : tablica; możliwy jest również inny poprawny zapis: var dane : array[1..10] of integer; Dostęp do elementów tablicy jest realizowany za pośrednictwem indeksu, który wskazuje dany element. Dla deklaracji tablicy w języku Delphi zawartej poniżej: var dane : array[1..10] of integer; pierwszy element tablicy dane ma indeks 1, drugi element dostępny jest przez indeks 2 itd. Ostatni element tablicy ma indeks równy wymiarowi tablicy, czyli 10, co zilustrowano na rysunku poniżej. 1 2 3 4 5 6 7 8 9 10 Oto prosty przykład programu ilustrujący posługiwanie się tablicą jednowymiarową. Copyright by Złote Myśli & Mirosław J. Kubiak
  6. 6. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 7 Mirosław J. Kubiak Program (Tablica1) Formularz Na formularzu wykonujemy następujące czynności: 1. umieszczamy dwa przyciski Button, jeden u góry z prawej strony (Button1) i jeden na dole również z prawej strony (Button2), 2. następnie klikamy myszą raz na Button1 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button1 na Zacznij, 3. klikamy myszą raz na Button2 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button2 na Zakończ, 4. z lewej górnej strony formularza umieszczamy komponent StringGrid, 5. dwukrotnie klikamy na formularzu przycisk Zakończ i podpinamy związaną z nim procedurę procedure TForm1.Button2Click(Sender: TObject); begin Close; end; 6. następnie dwukrotnie klikamy na formularzu przycisk Zacznij i podpinamy związaną z nim procedurę procedure TForm1.Button1Click(Sender: TObject), która została opisana w programie poniżej. Copyright by Złote Myśli & Mirosław J. Kubiak
  7. 7. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 8 Mirosław J. Kubiak Rys. 8.1. Formularz skonstruowany dla programu Tablica1, na którym zamieszczono komponent StringGrid. unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Grids; type TForm1 = class(TForm) Button1: TButton; Button2: TButton; StringGrid1: TStringGrid; procedure Button1Click(Sender: TObject); procedure Button2Click(Sender: TObject); private { Private declarations } public { Public declarations } end; Copyright by Złote Myśli & Mirosław J. Kubiak
  8. 8. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 9 Mirosław J. Kubiak var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.Button1Click(Sender: TObject); const n = 10; type tablica = array[1..n] of integer; var i : integer; dane : tablica; begin StringGrid1.ColCount:=2; // ustalenie ilosci kolumn StringGrid1.RowCount:=n+1; //ustalenie ilosci wierszy StringGrid1.Cells[0,0]:='Indeks tabl.'; StringGrid1.Cells[1,0]:='Wart. tabl.'; for i:=1 to n do StringGrid1.Cells[0,i]:=IntToStr(i); //opis wierszy for i:=1 to n do begin dane[i]:=i; StringGrid1.Cells[1,i]:=IntToStr(dane[i]); end; end; procedure TForm1.Button2Click(Sender: TObject); begin Close(); end; end. Copyright by Złote Myśli & Mirosław J. Kubiak
  9. 9. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 10 Mirosław J. Kubiak C++ Builder Oto ogólna postać zadeklarowania w języku w C++ Builder tablicy jednowymiarowej i związanej z nią zmiennej. typ_tablicy nazwa_tablicy [rozmiar_tablicy] A oto przykład zadeklarowania tablicy jednowymiarowej o nazwie dane typu całkowitego, zawierającej 10 elementów: int dane [10]; Dostęp do elementów tablicy Dostęp do elementów tablicy jest realizowany za pośrednictwem indeksu, który wskazuje dany element. Dla deklaracji tablicy int dane [10]; aby uzyskać dostęp do pierwszego elementu tablicy dane, powinniśmy podać indeks 01, drugi element dostępny jest przez indeks 1 itd. Ostatni element tablicy ma indeks równy rozmiarowi tablicy minus 1, czyli 9, co zilustrowano na rysunku poniżej. 0 1 2 3 4 5 6 7 8 9 Oto prosty przykład ilustrujący posługiwanie się tablicą jednowymiarową. 1 Indeks pierwszego elementu tablicy w języku C++ wynosi zawsze 0. Copyright by Złote Myśli & Mirosław J. Kubiak
  10. 10. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 11 Mirosław J. Kubiak Program (Tablica1) Formularz Na formularzu wykonujemy następujące czynności: 1. umieszczamy dwa przyciski Button, jeden u góry z prawej strony (Button1) i jeden na dole również z prawej strony (Button2), 2. następnie klikamy myszą raz na Button1 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button1 na Zacznij, 3. klikamy myszą raz na Button2 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button2 na Zakończ, 4. z lewej górnej strony formularza umieszczamy komponent StringGrid, 5. dwukrotnie klikamy na formularzu przycisk Zakończ i podpinamy związaną z nim funkcję void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } 6. następnie dwukrotnie klikamy na formularzu przycisk Zacznij i podpinamy związaną z nim funkcję void __fastcall TForm1::Button1Click(TObject *Sender), która została opisana w programie poniżej. Copyright by Złote Myśli & Mirosław J. Kubiak
  11. 11. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 12 Mirosław J. Kubiak //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include quot;Unit1.hquot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource quot;*.dfmquot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { const n=10; int i; int dane[10]; StringGrid1->ColCount=2; //ustalenie ilosci kolumn StringGrid1->RowCount=n+1; //ustalenie ilosci wierszy StringGrid1->Cells[0][0]=quot;Indeks tablicyquot;; StringGrid1->Cells[1][0]=quot;Wart. tabl.quot;; for (i=0; i<10; i++) { StringGrid1->Cells[0][i+1]=IntToStr(i); //opis wierszy } for (i=0; i<10; i++) { dane[i]=i; StringGrid1->Cells[1][i+1]=IntToStr(dane[i]); } } Copyright by Złote Myśli & Mirosław J. Kubiak
  12. 12. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 13 Mirosław J. Kubiak //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } //--------------------------------------------------------------------------- Sito Eratostenesa Około roku 200 p.n.e. matematyk grecki Eratostenes podał algorytm na znajdowanie liczb pierwszych. Liczby pierwsze to są liczby naturalne większe od 1, które dzielą się przez siebie i przez 1. Nazwa tego najstarszego algorytmu na znajdowanie liczb pierwszych pochodzi od sposobu, w jaki te liczby są znajdowane. Wszystkie liczby po kolei przesiewa się, usuwając z spośród nich wszystkie wielokrotności danej liczby. Zilustrujemy to przykładem, znajdując za pomocą sita Eratostenesa wszystkie liczby pierwsze z zakresu od 2 do 30, które umieścimy w tabeli poniżej. 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 Liczba 2 jest liczbą pierwszą, pozostałe znajdujemy po usunięciu z tabeli wielokrotności liczby 2 (gdyż nie są to liczby pierwsze) otrzymując: 2 3 * 5 * 7 * 9 * 11 * 13 * 15 * 17 * 19 * 21 * 23 * 25 * 27 * 29 * Copyright by Złote Myśli & Mirosław J. Kubiak
  13. 13. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 14 Mirosław J. Kubiak Kolejny etap polega na usunięciu z tabeli po liczbie 3 (przyjmuje się, że jest to liczba pierwsza) wielokrotności liczby 3. Rezultat tego działania znajduje się poniżej: 2 3 * 5 * 7 * * * 11 * 13 * * * 17 * 19 * * * 23 * 25 * * * 29 * Z pozostałych teraz liczb kolejną po 2 i 3 jest liczba 5, którą pozostawia się wykreślając wszystkie liczby podzielne przez 5: 2 3 * 5 * 7 * * * 11 * 13 * * * 17 * 19 * * * 23 * * * * * 29 * Kontynuując to wykreślanie dojdziemy do sytuacji, kiedy zostaną wykreślone wszystkie liczby, które nie są pierwsze i pozostaną tylko liczby pierwsze. W tym momencie możemy zakończyć nasze poszukiwania liczb pierwszych pamiętając, że kolejne wykreślenia należy powtarzać, nie dalej jak do liczby będącej zaokrąglonym w dół pierwiastkiem kwadratowym ze zmiennej zakres. W naszym przykładzie jest to: sqrt(30)=5.477.., po zaokrągleniu w dół2 otrzymujemy liczbę 5. W tabeli pozostały już tylko liczby pierwsze, które wyświetlamy na ekranie. Górny zakres, dla którego chcemy odnaleźć liczby pierwsze wyznaczony jest tylko rozmiarem tablicy. W naszym programie jest to: 2 W języku C++ Builder realizuje to matematyczna funkcja floor(), która znajduje się w pliku nagłówkowym math.h. Copyright by Złote Myśli & Mirosław J. Kubiak
  14. 14. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 15 Mirosław J. Kubiak int tablica[10000]; Chcąc zmienić ten zakres, należy zmienić rozmiar tablicy. C++ Builder (Sito) //--------------------------------------------------------------------------- #include <vcl.h> #include <math.h> #pragma hdrstop #include quot;Unit1.hquot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource quot;*.dfmquot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { int i,j,zakres,zm_pom; int tablica[10000]; zakres=StrToInt(InputBox(quot;Podaj gorny zakres liczb Copyright by Złote Myśli & Mirosław J. Kubiak
  15. 15. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 16 Mirosław J. Kubiak pierwszychquot;,quot;Maksymalny gorny zakres wynosi 9999quot;,quot;quot;)); zm_pom = floor(sqrt(zakres)); for (i=1; i<=zakres; i++) tablica[i]=i; for (i=2; i<=zm_pom; i++) if (tablica[i]!=0) for (j=i+1; j<=zakres; j++) if (j%i==0) tablica[j]=0; ListBox1->Items->Clear(); ListBox1->Items->Add(quot;Liczby pierwsze z zakresu od 1 do quot;+IntToStr(zakres)+quot; toquot;); for (i=2; i<=zakres; i++) if (tablica[i]!=0) ListBox1->Items->Add(IntToStr(i)); } //--------------------------------------------------------------------------- Tablice dwuwymiarowe Tablice dwuwymiarowe deklarujemy analogicznie jak tablice jednowymiarowe. Ilustrują to poniższe przykłady. Tablice wielowymiarowe deklarujemy analogicznie. Delphi A oto program napisany w języku Delphi, który w zadeklarowanej tablicy dwuwymiarowej 10x10 umieszcza na przekątnej jedynki, a poza przekątną zera. W programie skorzystaliśmy z komponentu StringGrid. Copyright by Złote Myśli & Mirosław J. Kubiak
  16. 16. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 17 Mirosław J. Kubiak Program (Tablica2) – formularz jak na Rys. 8.1. unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Grids; type TForm1 = class(TForm) Button1: TButton; Button2: TButton; StringGrid1: TStringGrid; procedure Button1Click(Sender: TObject); procedure Button2Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.Button1Click(Sender: TObject); const n = 10; type macierz = array[1..n, 1..n] of integer; Copyright by Złote Myśli & Mirosław J. Kubiak
  17. 17. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 18 Mirosław J. Kubiak var i, j : integer; tablica : macierz; begin StringGrid1.ColCount:=n+1; //ustalenie ilosci kolumn tabeli StringGrid1.RowCount:=n+1; //ustalenie ilosci wierszy tabeli StringGrid1.DefaultColWidth:=25; //ustalenie wysokosci komorki StringGrid1.DefaultRowHeight:=25; //ustalenie szerokosci komorki for i:=1 to n do begin StringGrid1.Cells[i,0]:=IntToStr(i); StringGrid1.Cells[0,i]:=IntToStr(i); end; {wpisywanie do tablicy 1 na przekątnej, a 0 poza przekątną} for i:=1 to n do begin for j:=1 to n do begin if i = j then tablica[i,j]:=1 else tablica[i,j]:=0 end; {j} end; {i} {Koniec wpisywania} {Wydruk zawartosci tablicy} for i:=1 to n do begin for j:=1 to n do begin StringGrid1.Cells[i,j]:= IntToStr(tablica[i,j]); Copyright by Złote Myśli & Mirosław J. Kubiak
  18. 18. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 19 Mirosław J. Kubiak end; {j} end; {i} {Koniec wydruku} end; procedure TForm1.Button2Click(Sender: Tobject); begin Close(); end; end. Rys. 8.2. Rezultat działania programu Tablica2 napisanego w języku Delphi. Zachęcamy Czytelnika, aby dodatkowo wzbogacił program o obliczanie sumy elementów znajdujących się na przekątnej. C++ Builder A oto program napisany w języku C++ Builder, który w zadeklarowanej tablicy dwuwymiarowej 10x10 umieszcza na przekątnej jedynki, a poza przekątną zera. W programie skorzystaliśmy z komponentu StringGrid. Copyright by Złote Myśli & Mirosław J. Kubiak
  19. 19. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 20 Mirosław J. Kubiak Język C++ Builder (Tablica2) – formularz jak na Rys. 8.2. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include quot;Unit1.hquot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource quot;*.dfmquot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { const n=11; int i, j, suma; int macierz[11][11]; StringGrid1->ColCount=n; //ustalenie ilosci kolumn StringGrid1->RowCount=n; //ustalenie ilosci wierszy StringGrid1->DefaultColWidth=25; //ustalenie szerokosci komorki StringGrid1->DefaultRowHeight=25; //ustalenie szerokosci komorki for (i=0; i<=n; i++) //opis tablicy { StringGrid1->Cells[i+1][0]=IntToStr(i); StringGrid1->Cells[0][i+1]=IntToStr(i); } Copyright by Złote Myśli & Mirosław J. Kubiak
  20. 20. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 21 Mirosław J. Kubiak //wpisywanie 1 na przekatnej, a poza przekatna zero for (i=0; i<n; i++) { for (j=0; j<n; j++) { if (i==j) macierz[i][j]=1; // wpisanie 1 na przekatnej else macierz[i][j]=0; // wpisanie 0 poza przekatna } } //koniec wpisywania //wyswietlanie tablicy for (i=0; i<n; i++) { for (j=0; j<n; j++) { StringGrid1->Cells[i+1][j+1]=IntToStr(macierz[i][j]); } } } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } //--------------------------------------------------------------------------- Zachęcamy Czytelnika, aby dodatkowo wzbogacił program o obliczanie sumy elementów znajdujących się na przekątnej. Copyright by Złote Myśli & Mirosław J. Kubiak
  21. 21. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 22 Mirosław J. Kubiak Sortowanie bąbelkowe Następny program, który wykorzystuje tablice nazywa się Bąbelki. Metoda sortowania bąbelkowego opiera się na zasadzie porównywania i zamiany par sąsiadujących ze sobą liczb, do chwili ustawienia ich w kolejności od najmniejszej do największej. Wynika to stąd, że warunkiem uporządkowania jest jednoczesne udostępnienie wszystkich liczb (w programie jest ich 6). Jeśli potraktujemy zadane liczby jako element „pionowej” tablicy jednowymiarowej, to przy pewnej dozie wyobraźni możemy je uważać za znajdujące się w naczyniu z wodą bąbelki o „wadze” proporcjonalnej do ich wielkości. Rezultatem każdego przejścia przez tablicę będzie wypchnięcie bąbelka na poziom odpowiadający jego „wadze”. Tabela 8.1. Przebieg sortowania bąbelkowego po kolejnych przejściach dla 6 ustalonych liczb Ustawienie Pierwsze Drugie Trzecie Czwarte Piąte początkowe przejście przejście przejście przejście przejście 574 8 8 8 8 8 303 574 23 23 23 23 34 303 574 34 34 34 125 34 303 574 125 125 8 125 34 303 574 303 23 23 125 125 303 574 A oto program w Delphi, który zawiera algorytm sortowania bąbelkowego. Copyright by Złote Myśli & Mirosław J. Kubiak
  22. 22. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 23 Mirosław J. Kubiak Delphi (Bąbelki) – formularz jak na Rys. 8.1. unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, Grids, StdCtrls; type TForm1 = class(TForm) Button1: TButton; StringGrid1: TStringGrid; Button2: TButton; procedure Button1Click(Sender: TObject); procedure Button2Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.Button1Click(Sender: TObject); var liczby : array[1..6] of integer; x, i, j, k : integer; begin StringGrid1.ColCount:=7; //ustalenie ilosci kolumn StringGrid1.RowCount:=7; StringGrid1.Cells[1,0]:='Ust. pocz.'; Copyright by Złote Myśli & Mirosław J. Kubiak
  23. 23. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 24 Mirosław J. Kubiak for i:=1 to 6 do StringGrid1.Cells[i+1,0]:=IntToStr(i)+' przejscie'; liczby[1]:=574; liczby[2]:=303; liczby[3]:=34; liczby[4]:=125; liczby[5]:=8; liczby[6]:=23; for j:=1 to 6 do StringGrid1.Cells[1,j]:=IntToStr(liczby[j]); for i:=2 to 6 do begin for j:=6 downto i do begin if liczby[j-1]>liczby[j] then begin x := liczby[j-1]; liczby[j-1]:= liczby[j]; liczby[j] := x; end; for k:=i to 6 do begin StringGrid1.Cells[k,j-1]:=IntToStr(liczby[j-1]); StringGrid1.Cells[k,j]:=IntToStr(liczby[j]); end; end; end; end; procedure TForm1.Button2Click(Sender: TObject); begin close; end; end. Copyright by Złote Myśli & Mirosław J. Kubiak
  24. 24. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 25 Mirosław J. Kubiak C++ Builder (Bąbelki) – formularz jak na Rys. 8.1. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include quot;Unit1.hquot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource quot;*.dfmquot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { int x, i, j, k; int liczby[6]; StringGrid1->ColCount=7; //ustalenie ilosci kolumn StringGrid1->RowCount=7; //ustalenie ilosci wierszy StringGrid1->Cells[1][0]=quot;Ust. pocz.quot;; for (i=1; i<=6; i++) { StringGrid1->Cells[i+1][0]=IntToStr(i)+quot; przejsciequot;; } liczby[0]=574; liczby[1]=303; liczby[2]=34; liczby[3]=125; liczby[4]=8; Copyright by Złote Myśli & Mirosław J. Kubiak
  25. 25. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 26 Mirosław J. Kubiak liczby[5]=23; for (j=0; j<=5; j++) { StringGrid1->Cells[1][j +1]=IntToStr(liczby[j]); //ust.poczatkowe } for (i=1; i<=5; i++) { for(j=5; j>=i; --j) { if (liczby[j-1] > liczby[j]) { x = liczby[j-1]; liczby[j-1]=liczby[j]; liczby[j]= x; } for (k=i; k<=5; k++) { {StringGrid1->Cells[k+1][j]=IntToStr(liczby[j-1]); StringGrid1->Cells[k+1][j+1]=IntToStr(liczby[j]); } } //k } //j } //i } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } //--------------------------------------------------------------------------- Copyright by Złote Myśli & Mirosław J. Kubiak
  26. 26. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 27 Mirosław J. Kubiak Tablice przechowują również teksty Tablice przechowują nie tylko liczby, ale również teksty (ang. strings). Teksty są bardzo użyteczne w programach, gdyż mogą przechowywać informacje takie jak nazwy plików, tytuły książek, nazwiska pracowników i inne ciągi określonych znaków. Delphi W języku Turbo Pascal typ łańcuchowy (tekstowy) był ciągiem znaków (tekstem) poprzedzonym liczbą, która wskazywała rozmiar tego łańcucha. Ponieważ długość łańcucha mieściła się w jednym bajcie, to łańcuch mógł mieć maksymalnie tylko 255 znaków. 32- bitowa wersja Delphi ma dodatkowo wbudowany typ długich łańcuchów tekstowych. W Delphi istnieją trzy typy łańcuchów tekstowych: 1. typ ShortString, który odpowiada dawnym typom łańcuchowym w języku Turbo Pascal, 2. typ ANSIString odpowiada nowym, o zmiennej długości łańcuchom tekstowym z dynamicznym przydziałem pamięci – rozmiar tych łańcuchów jest praktycznie nieograniczony, 3. typ WideString jest podobny do typu ANSIString, również z dynamicznym przydziałem pamięci, lecz jest oparty na znakach typu WideChar, który obsługuje znaki wielobajtowe – system Unicode. Z łańcuchami związany jest szereg praktycznych funkcji (dostarczonych przez producentów oprogramowania) pozwalających na swobodne operacje na tekstach. Zilustrujemy to odpowiednimi przykładami, zachęcając Czytelnika do samodzielnego eksperymentowania z pozostałymi funkcjami. Copyright by Złote Myśli & Mirosław J. Kubiak
  27. 27. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 28 Mirosław J. Kubiak Pierwszy z programów - Długość łańcucha - umożliwia odczytywanie długości łańcucha zapamiętanego w odpowiedniej zmiennej. Delphi (Długość Łańcucha) Formularz Na formularzu wykonujemy następujące czynności: 1. umieszczamy dwa przyciski Button, jeden u góry (Button1) i jeden na dole z prawej strony (Button2), 2. następnie klikamy myszą raz na Button1 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button1 na Zacznij, 3. klikamy myszą raz na Button2 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button2 na Zakończ, 4. u góry formularza z jego lewej strony umieszczamy komponent Edit, w Object Inspectorze usuwamy słowo Edit1 we właściwościach (Properties) w Text. 5. na dole formularza z jego lewej strony umieszczamy komponent ListBox, 6. dwukrotnie klikamy na formularzu przycisk Zakończ i podpinamy związaną z nim procedurę procedure TForm1.Button2Click(Sender: TObject); begin Close; Copyright by Złote Myśli & Mirosław J. Kubiak
  28. 28. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 29 Mirosław J. Kubiak end; 7. następnie dwukrotnie klikamy na formularzu przycisk Zacznij i podpinamy związaną z nim procedurę procedure TForm1.Button1Click(Sender: TObject), która została opisana w programie poniżej. Wydruk całego programu. unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) Button1: TButton; Edit1: TEdit; ListBox1: TListBox; Button2: TButton; procedure Button1Click(Sender: TObject); procedure Button2Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; Copyright by Złote Myśli & Mirosław J. Kubiak
  29. 29. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 30 Mirosław J. Kubiak implementation {$R *.dfm} procedure TForm1.Button1Click(Sender: TObject); var imie : AnsiString; nazwisko : AnsiString; begin Edit1.Text:='Program mierzy długosc łancucha imie i nazwisko'; imie:=InputBox('','Podaj imie',''); nazwisko:=InputBox('','Podaj nazwisko',''); ListBox1.Items.Clear; ListBox1.Items.Add('Imie '+imie+' zawiera '+IntToStr(Length(imie))+' liter(y).'); ListBox1.Items.Add('Nazwisko '+nazwisko+' zawiera '+IntToStr(Length(nazwisko))+' liter(y).'); end; procedure TForm1.Button2Click(Sender: TObject); begin Close; end; end. W programie powyżej skorzystaliśmy z gotowej funkcji Length(zmienna_łańcuchowa). Wynikiem jest długość łańcucha znaków zmienna_łańcuchowa, czyli liczba przedstawiająca liczbę znaków, z których się on składa. Wynik jest typu integer. Copyright by Złote Myśli & Mirosław J. Kubiak
  30. 30. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 31 Mirosław J. Kubiak C++ Builder Język C++ Builder dostarcza nowego mechanizmu obsługi łańcuchów znaków – klasę AnsiString. Klasa ta posiada szereg metod, które umożliwiają obsługę łańcuchów znakowych (zobacz: Dorobek, 2002). Oto przykład zadeklarowania dwóch zmiennych klasy AnsiString: AnsiString imie, nazwisko; Program (Długość łańcucha) umożliwia odczytywanie długości łańcucha zapamiętanego w odpowiedniej zmiennej. Formularz Na formularzu wykonujemy następujące czynności: 1. umieszczamy dwa przyciski Button, jeden u góry (Button1) i jeden na dole z prawej strony (Button2), 2. następnie klikamy myszą raz na Button1 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button1 na Zacznij, 3. klikamy myszą raz na Button2 i w Object Inspectorze zmieniamy we właściwościach (Properties) w Caption tekst Button2 na Zakończ, 4. u góry formularza z jego lewej strony umieszczamy komponent Edit, w Object Inspectorze usuwamy słowo Edit1 we właściwościach (Properties) w Text. 5. na dole formularza z jego lewej strony umieszczamy komponent ListBox, 6. dwukrotnie klikamy na formularzu przycisk Zakończ i podpinamy związaną z nim funkcję void __fastcall Copyright by Złote Myśli & Mirosław J. Kubiak
  31. 31. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 32 Mirosław J. Kubiak TForm1::Button2Click(TObject *Sender) { Close(); } 7. następnie dwukrotnie klikamy na formularzu przycisk Zacznij i podpinamy związaną z nim funkcję void __fastcall TForm1::Button1Click(TObject *Sender), która została opisana w programie poniżej. Wydruk całego programu. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include quot;Unit1.hquot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource quot;*.dfmquot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { Copyright by Złote Myśli & Mirosław J. Kubiak
  32. 32. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 33 Mirosław J. Kubiak AnsiString imie, nazwisko; Edit1->Text=quot;Program mierzy dlugosc lancucha imie i nazwiskoquot;; imie=InputBox(quot;quot;,quot;Podaj imiequot;, quot;quot;); nazwisko=InputBox(quot;quot;,quot;Podaj nazwiskoquot;, quot;quot;); ListBox1->Items->Clear(); ListBox1->Items->Add(quot;Imie quot;+imie+ quot; zawiera quot;+IntToStr(imie.Length())+quot; liter(y).quot;); ListBox1->Items->Add(quot;Nazwisko quot;+nazwisko+ quot; zawiera quot;+IntToStr(nazwisko.Length())+quot; liter(y).quot;); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } //--------------------------------------------------------------------------- W programie skorzystaliśmy z metody Length() klasy AnsiString. W następnym przykładzie wykorzystamy możliwości składania łańcuchów. Łączenie łańcuchów (konkatenacja) w języku Delphi umożliwia nam funkcja Concat(łańcuch_1, łańcuch_2, łańcuch_n), która łączy kilka łańcuchów w jeden łańcuch. Musimy pamiętać, że składanie różnych łańcuchów nie jest przemienne, co łatwo możemy sprawdzić wprowadzając łańcuchy ma i ta. Copyright by Złote Myśli & Mirosław J. Kubiak
  33. 33. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 34 Mirosław J. Kubiak Delphi (Concat) – formularz jak wyżej. unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) Button1: TButton; Edit1: TEdit; ListBox1: TListBox; Button2: TButton; procedure Button1Click(Sender: TObject); procedure Button2Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.Button1Click(Sender: TObject); var lancuch_1 : AnsiString; lancuch_2 : AnsiString; Copyright by Złote Myśli & Mirosław J. Kubiak
  34. 34. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 35 Mirosław J. Kubiak begin Edit1.Text:='Program dodaje dwa łancuchy'; lancuch_1:=InputBox('','Podaj pierwszy tekst',''); lancuch_2:=InputBox('','Podaj drugi tekst',''); ListBox1.Items.Clear; ListBox1.Items.Add('Po dodaniu lancuch_1 + lancuch_2 -> '+Concat(lancuch_1,lancuch_2)); ListBox1.Items.Add('Po dodaniu lancuch_2 + lancuch_1 -> '+Concat(lancuch_2,lancuch_1)); ListBox1.Items.Add(''); ListBox1.Items.Add('Składanie łancuchow nie jest przemienne'); end; procedure TForm1.Button2Click(Sender: TObject); begin Close; end; end. C++ Builder (Concat) – formularz jak wyżej. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include quot;Unit1.hquot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource quot;*.dfmquot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) Copyright by Złote Myśli & Mirosław J. Kubiak
  35. 35. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 36 Mirosław J. Kubiak { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString lancuch_1, lancuch_2; Edit1->Text=quot;Program dodaje 2 lancuchyquot;; lancuch_1=InputBox(quot;quot;,quot;Podaj pierwszy tekstquot;, quot;quot;); lancuch_2=InputBox(quot;quot;,quot;Podaj drugi tekstquot;, quot;quot;); ListBox1->Items->Clear(); ListBox1->Items->Add(quot;Po dodaniu lancuch_1+lancuch_2->quot;+(lancuch_1+lancuch_2)); ListBox1->Items->Add(quot;Po dodaniu lancuch_2+lancuch_1->quot;+(lancuch_2+lancuch_1)); ListBox1->Items->Add(quot;quot;); ListBox1->Items->Add(quot;Skladanie lancuchow nie jest przemiennequot;); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } //--------------------------------------------------------------------------- Na koniec zaproponujemy następujące zadanie: Mając na wejściu ciąg napisów np. qqqq, asd, asdgfter, wGee, yuiyu, weerw, f, ytu4df należy wyprowadzić elementy o nieparzystej długości oraz długość i nr elementu najdłuższego i najkrótszego3. Rozwiązanie dla obu języków programowania znajduje się poniżej. 3 Odpowiedź: na wyjściu powinniśmy otrzymać następujące wynik asd, yuiyu, weerw, f, 8, 3, 1, 7. Copyright by Złote Myśli & Mirosław J. Kubiak
  36. 36. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 37 Mirosław J. Kubiak Delphi (Zadanie) unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) Button1: TButton; Button2: TButton; ListBox1: TListBox; procedure Button2Click(Sender: TObject); procedure Button1Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.Button2Click(Sender: TObject); begin Close; end; procedure TForm1.Button1Click(Sender: TObject); Copyright by Złote Myśli & Mirosław J. Kubiak
  37. 37. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 38 Mirosław J. Kubiak var tekst: array[1..8] of string; i, max, min, j, k : integer; begin tekst[1]:='qqqq'; tekst[2]:='asd'; tekst[3]:='asdgfter'; tekst[4]:='wGee'; tekst[5]:='yuiyu'; tekst[6]:='weerw'; tekst[7]:='f'; tekst[8]:='ytu4df'; max:=1; min:=1; ListBox1.Items.Clear(); for i:=1 to 8 do begin if (Length(tekst[i]) mod 2 <> 0)then ListBox1.Items.Add(tekst[i]); if max < Length(tekst[i]) then begin max:=Length(tekst[i]); j:=i; end; if Length(tekst[i]) <= min then begin min:=Length(tekst[i]); k:=i; end; end; ListBox1.Items.Add(IntToStr(max)+' '+IntToStr(j)+' '+IntToStr(min)+' '+IntToStr(k)); end; end. Copyright by Złote Myśli & Mirosław J. Kubiak
  38. 38. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 39 Mirosław J. Kubiak C++ Builder (Zadanie) //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include quot;Unit1.hquot; //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource quot;*.dfmquot; TForm1 *Form1; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { Close(); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { AnsiString tekst[8][9]; int i, max, min, j, k, l; tekst[0][8]=quot;qqqqquot;; tekst[1][8]=quot;asdquot;; tekst[2][8]=quot;asdgfterquot;; tekst[3][8]=quot;wGeequot;; tekst[4][8]=quot;yuiyuquot;; tekst[5][8]= quot;weerwquot;; tekst[6][8]=quot;fquot;; tekst[7][8]=quot;ytu4dfquot;; Copyright by Złote Myśli & Mirosław J. Kubiak
  39. 39. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 40 Mirosław J. Kubiak max=1; min=1; ListBox1->Items->Clear(); for (i=0; i < 8; i++) { for(j=0; j < 9; j++) { if (IntToStr(tekst[i][j].Length()) % 2 != 0) ListBox1- >Items->Add(tekst[i][j]); if (max < IntToStr(tekst[i][j].Length())) { max = StrToInt(tekst[i][j].Length()); k=i; } if (IntToStr(tekst[i][j].Length()) == min) { min = StrToInt(tekst[i][j].Length()); l=i; } } //j } //i ListBox1->Items->Add(IntToStr(max)+quot; quot;+IntToStr(k +1)+quot; quot;+IntToStr(min)+quot; quot;+IntToStr(l+1)); } //--------------------------------------------------------------------------- Copyright by Złote Myśli & Mirosław J. Kubiak
  40. 40. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 41 Mirosław J. Kubiak Warto zapamiętać 1. Tablica to taka struktura danych, która umożliwia jednej zmiennej przechowywanie wielu wartości tego samego typu. 2. Deklarując tablicę musimy określić typ wartości, jakie ma ona przechowywać, a także liczbę jej elementów. 3. Wszystkie elementy zadeklarowanej tablicy są tego samego typu. 4. Wstawienie elementu do tablicy odbywa się w programie poprzez podanie numeru indeksu w tablicy, pod którym dana wartość ma być umieszczona. 5. Uzyskanie dostępu do wartości przechowywanej w tablicy odbywa się w programie poprzez podanie nazwy tablicy i numeru elementu. 6. Tablice przechowują również teksty. Copyright by Złote Myśli & Mirosław J. Kubiak
  41. 41. PROGRAMUJĘ W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej ● str. 42 Mirosław J. Kubiak Jak skorzystać z wiedzy zawartej w pełnej wersji ebooka? Więcej praktycznych porad dotyczących programowania w Delphi i C ++ Buider znajdziesz w pełnej wersji ebooka. Zapoznaj się z opisem na stronie: http://programowanie-delphi-builder.zlotemysli.pl Poznaj jeszcze więcej sekretów programowania w Delphi i C++ Builder! Copyright by Złote Myśli & Mirosław J. Kubiak
  42. 42. POLECAMY TAKŻE PORADNIKI: Sekrety języka C# (c-sharp) – Andrzej Stefańczyk Dlaczego tworzenie aplikacji w Visual Studio .NET 2005 jest takie proste? Ebook quot;Sekrety języka C#quot; uczy zarówno składni nowego języka C# jak również zasad tworzenia aplikacji okienkowych dla systemu Windows w tym języku. Przeznaczony jest zarówno dla osób, które nie miały do tej pory styczności z programowaniem jak i dla osób, które programowały wcześniej w innych językach i chciałyby poznać możliwości C# ( c-sharp). Więcej o tym poradniku przeczytasz na stronie: http://c-sharp.zlotemysli.pl quot;Świetna pozycja dla chcących się nauczyć C# w .NET-cie zwięźle opisuje dany problem i przedstawia rozwiązania. Po prostu bomba.quot; - webmax, student WISZ-u z Gorzowa Wlkp. Visual Basic 2005 Express i MySQL – Łukasz Peta Jak szybko i prosto utworzyć rozbudowaną aplikacje bazodanową? Ebook quot;Visual Basic 2005 Express i MySQLquot; uczy zarówno składni języka Visual Basic jak również zasad tworzenia aplikacji opartych o bazę danych MySQL dla systemu Windows w tym języku, a został napisany głównie z myślą o początkujących programistach Więcej o tym poradniku przeczytasz na stronie: http://visual-basic.zlotemysli.pl quot;Nie dosyc, ze e-book, to jeszcze dodatkowo kody i przyklady aplikacji do nauki. Bardzo wartosciowy e-book. Czysto i prosto przekazana wiedza. Polecam.quot; David 27 lat, programista Zobacz pełen katalog naszych praktycznych poradników na stronie www.zlotemysli.pl

×