Niniejszy darmowy ebook zawiera fragment
pełnej wersji pod tytułem:
"ProgramujÄ™ w Delphi i C++ Builder"
Aby przeczytać informacje o pełnej wersji, kliknij tutaj.
Darmowa publikacja dostarczona przez
ZloteMysli.pl
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.
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. Wskaz
niki..................................................................202
Wprowadzenie.................................................................................................202
Wskaz
niki i tablice...........................................................................................207
Programy mogą przekazywać podprogramom informacje  ciąg dalszy......213
Przekazywanie parametrów przez wskaz
nik...................................................214
Przekazywanie parametrów przez referencję..................................................217
Warto zapamiętać............................................................................................219
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
PROGRAMUJ
W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
str. 5
Mirosław J. Kubiak
Rozdział 8. Tablice
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
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
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
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
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
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
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
PROGRAMUJ
W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
str. 12
Mirosław J. Kubiak
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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]="Indeks tablicy";
StringGrid1->Cells[1][0]="Wart. tabl.";
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
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
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 odnalez
ć 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
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
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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("Podaj gorny zakres liczb
Copyright by Złote Myśli & Mirosław J. Kubiak
PROGRAMUJ
W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
str. 16
Mirosław J. Kubiak
pierwszych","Maksymalny gorny zakres wynosi 9999",""));
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("Liczby pierwsze z zakresu od 1 do
"+IntToStr(zakres)+" to");
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
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
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
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
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
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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
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 {
for (j=0; 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 {
for (j=0; 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
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 wyobraz
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
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
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
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
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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]="Ust. pocz.";
for (i=1; i<=6; i++)
{
StringGrid1->Cells[i+1][0]=IntToStr(i)+" przejscie";
}
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
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
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
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
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
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
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
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
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
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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
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="Program mierzy dlugosc lancucha imie i
nazwisko";
imie=InputBox("","Podaj imie", "");
nazwisko=InputBox("","Podaj nazwisko", "");
ListBox1->Items->Clear();
ListBox1->Items->Add("Imie "+imie+ " zawiera
"+IntToStr(imie.Length())+" liter(y).");
ListBox1->Items->Add("Nazwisko "+nazwisko+ " zawiera
"+IntToStr(nazwisko.Length())+" liter(y).");
}
//---------------------------------------------------------------------------
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.
A
ą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
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
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
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
Copyright by Złote Myśli & Mirosław J. Kubiak
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="Program dodaje 2 lancuchy";
lancuch_1=InputBox("","Podaj pierwszy tekst", "");
lancuch_2=InputBox("","Podaj drugi tekst", "");
ListBox1->Items->Clear();
ListBox1->Items->Add("Po dodaniu
lancuch_1+lancuch_2->"+(lancuch_1+lancuch_2));
ListBox1->Items->Add("Po dodaniu
lancuch_2+lancuch_1->"+(lancuch_2+lancuch_1));
ListBox1->Items->Add("");
ListBox1->Items->Add("Skladanie lancuchow nie jest
przemienne");
}
//---------------------------------------------------------------------------
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
Odpowiedz
: 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
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
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
PROGRAMUJ
W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
str. 39
Mirosław J. Kubiak
C++ Builder (Zadanie)
//---------------------------------------------------------------------------
#include
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
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]="qqqq";
tekst[1][8]="asd";
tekst[2][8]="asdgfter";
tekst[3][8]="wGee";
tekst[4][8]="yuiyu";
tekst[5][8]= "weerw";
tekst[6][8]="f";
tekst[7][8]="ytu4df";
Copyright by Złote Myśli & Mirosław J. Kubiak
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)+" "+IntToStr(k
+1)+" "+IntToStr(min)+" "+IntToStr(l+1));
}
//---------------------------------------------------------------------------
Copyright by Złote Myśli & Mirosław J. Kubiak
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
PROGRAMUJ
W DELPHI I C++ BUILDER Cz. II - darmowy fragment - kliknij po więcej
str. 42
Mirosław J. Kubiak
Jak skorzystać z wiedzy
Jak skorzystać z wiedzy
zawartej w pełnej wersji ebooka?
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
POLECAMY TAKŻE PORADNIKI:
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 "Sekrety języka C#" 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
"Świetna pozycja dla chcących się nauczyć C# w .NET-cie zwięz
le opisuje
dany problem i przedstawia rozwiÄ…zania. Po prostu bomba."
- webmax, student WISZ-u z Gorzowa Wlkp.
Visual Basic 2005 Express i MySQL  A
ukasz Peta
Jak szybko i prosto
utworzyć rozbudowaną aplikacje
bazodanowÄ…?
Ebook "Visual Basic 2005 Express i MySQL" 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
"Nie dosyc, ze e-book, to jeszcze dodatkowo kody i przyklady aplikacji do
nauki. Bardzo wartosciowy e-book. Czysto i prosto przekazana wiedza.
Polecam."
David 27 lat, programista
Zobacz pełen katalog naszych praktycznych poradników
na stronie www.zlotemysli.pl


Wyszukiwarka

Podobne podstrony:
ProgramujÄ™ w Delphi i C Builder cz 2
Mirosław J Kubiak Programuję w Delphi i C Builder cz 2
Programuje w Delphi i C Builder
Programuje w Delphi i C Builder II czesc
Programuję w Delphi i C Builder Mirosław J Kubiak
RS 232C praktyczne programowanie Od Pascala i C do Delphi i Buildera Wydanie III
Praktyczny kurs programowania w Delphi
program treningu szybkości cz 2
Konspekt szkoleniowy Podstawy programowania w Delphi
Programowanie w Delphi dla Win32

więcej podobnych podstron