Pascal - Hızlı Kılavuz

Pascal, 1970'lerin başlarında Niklaus Wirth tarafından geliştirilen genel amaçlı, yüksek seviyeli bir dildir. Programlamayı sistematik bir disiplin olarak öğretmek ve güvenilir ve verimli programlar geliştirmek için geliştirilmiştir.

Pascal, Algol tabanlı bir dildir ve birçok Algol yapısını içerir. Algol 60, Pascal'ın bir alt kümesidir. Pascal birkaç veri türü ve programlama yapısı sunar. Pascal programlarını anlamak ve sürdürmek kolaydır.

Pascal, çeşitli nedenlerle öğretim ve akademik arenada popülerliğini artırmıştır:

• Öğrenmesi kolay.
• Yapılandırılmış dil.
• Şeffaf, verimli ve güvenilir programlar üretir.
• Çeşitli bilgisayar platformlarında derlenebilir.

Pascal Dilinin Özellikleri

Pascal aşağıdaki özelliklere sahiptir -

• Pascal güçlü yazılmış bir dildir.
• Kapsamlı hata kontrolü sunar.
• Diziler, kayıtlar, dosyalar ve kümeler gibi çeşitli veri türleri sunar.
• Çeşitli programlama yapıları sunar.
• Fonksiyonlar ve prosedürler aracılığıyla yapısal programlamayı destekler.
• Nesne yönelimli programlamayı destekler.

Pascal hakkında gerçekler

• Pascal dili, Fransız matematikçi ve bilgisayar geliştirmede öncü olan Blaise Pascal'dan alınmıştır.

• Niklaus Wirth, orijinal Pascal programlama dilinin geliştirilmesini 1970 yılında tamamladı.

• Pascal, Algol programlama dilinin blok yapılı stiline dayanmaktadır.

• Pascal, uygulamaları hem güvenilir hem de verimli olabilecek sistematik bir disiplin olarak programlamayı öğretmeye uygun bir dil olarak geliştirilmiştir.

• ISO 7185 Pascal Standardı ilk olarak 1983'te yayınlandı.

• Pascal, Apple Lisa'da ve Mac'in ilk yıllarında geliştirme için kullanılan birincil yüksek seviyeli dildi.

• 1986'da Apple Computer ilk Object Pascal uygulamasını yayınladı ve 1993'te Pascal Standartları Komitesi, Pascal'a bir Nesne Yönelimli Uzantı yayınladı.

Pascal'ı neden kullanmalı?

Pascal, programcıların karmaşık yapılandırılmış veri türlerini tanımlamalarına ve listeler, ağaçlar ve grafikler gibi dinamik ve yinelemeli veri yapıları oluşturmalarına olanak tanır. Pascal; kayıtlar, numaralandırmalar, alt aralıklar, dinamik olarak tahsis edilmiş değişkenler ve ilişkili işaretçiler ve kümeler gibi özellikler sunar.

Pascal, herhangi bir derinlik düzeyinde iç içe geçmiş prosedür tanımlarına izin verir. Bu, programlamayı temel kavramlara dayanan sistematik bir disiplin olarak öğrenmek için gerçekten harika bir programlama ortamı sağlar.

Pascal'ın en şaşırtıcı uygulamaları arasında şunlar vardır:

• Skype
• Toplam Amir
• TeX
• Macromedia Captivate
• Apple Lisa
• Çeşitli PC Oyunları
• Gömülü sistemler

Genel kullanım için birkaç Pascal derleyicisi ve yorumlayıcısı vardır. Bunların arasında -

• Turbo Pascal - Pascal programlarını CP / M, CP / M-86, DOS, Windows ve Macintosh'ta çalıştırmak için bir IDE ve derleyici sağlar.

• Delphi- Object Pascal'ı çalıştırmak için derleyiciler sağlar ve 32-bit Mac OS X ve iOS'un yanı sıra 32 ve 64-bit Windows işletim sistemleri için yerel kod üretir. Embarcadero, Linux ve Android işletim sistemi için destek oluşturmayı planlıyor.

• Free Pascal- Pascal ve Object Pascal programlarını çalıştırmak için ücretsiz bir derleyicidir. Free Pascal derleyicisi Linux, Windows, OS / 2, FreeBSD, Mac OS X, DOS ve diğer birçok platform için 32 ve 64-bit Turbo Pascal ve Delphi uyumlu bir Pascal derleyicisidir.

• Turbo51 - Turbo Pascal 7 sözdizimine sahip, 8051 mikrodenetleyici ailesi için ücretsiz bir Pascal derleyicisidir.

• Oxygene - .NET ve Mono platformları için bir Object Pascal derleyicisidir.

• GNU Pascal (GPC) - GNU Derleyici Koleksiyonunun bir ön ucundan oluşan bir Pascal derleyicisidir.

Bu eğitimlerde Free Pascal'ı kullanacağız. Free Pascal'ı işletim sisteminiz için şu bağlantıdan indirebilirsiniz: Free Pascal'ı İndirin

Free Pascal'ı Linux'a Kurmak

Free Pascal'ın Linux dağıtımı üç biçimde gelir -

• a tar.gz sürüm, ayrı dosyalar olarak da mevcuttur.

• a .rpm (Red Hat Paket Yöneticisi) sürümü.

• a .deb (Debian) sürümü.

.Rpm sürümü için kurulum kodu ::

rpm -i fpc-X.Y.Z-N.ARCH.rpm

XYZ, .rpm dosyasının sürüm numarasıdır ve ARCH, desteklenen mimarilerden biridir (i386, x86_64, vb.).

Debian sürümü için kurulum kodu (Ubuntu gibi) -

dpkg -i fpc-XXX.deb

XXX, .deb dosyasının sürüm numarasıdır.

Ayrıntılar için şunu okuyun: Free Pascal Kurulum Kılavuzu

Free Pascal'ı Mac'e Yükleme

Mac OS X kullanıyorsanız, Free Pascal'ı kullanmanın en kolay yolu, Xcode geliştirme ortamını Apple'ın web sitesinden indirmek ve basit kurulum talimatlarını izlemektir. Xcode kurulumunu yaptıktan sonra, Free Pascal derleyicisini kullanabileceksiniz.

Free Pascal'ı Windows'a Kurmak

Windows için, Windows yükleyici setup.exe'yi indireceksiniz. Bu normal bir kurulum programıdır. Kurulum için aşağıdaki adımları uygulamanız gerekir -

• Bir dizin seçin.

• Paketin kurmak istediğiniz kısımlarını seçin.

• İsteğe bağlı olarak, .pp veya .pas uzantılarını Free Pascal IDE ile ilişkilendirmeyi seçin.

Ayrıntılar için şunu okuyun: Free Pascal Kurulum Kılavuzu

Metin düzeltici

Bu, programınızı yazmak için kullanılacaktır. Birkaç düzenleyicinin örnekleri arasında Windows Not Defteri, İşletim Sistemi Düzenleme komutu, Kısa, Epsilon, EMACS ve vim veya vi bulunur.

Metin düzenleyicinin adı ve sürümü farklı işletim sistemlerine göre değişebilir. Örneğin, Windows'ta Not Defteri, Linux veya UNIX'in yanı sıra Windows'ta da vim veya vi kullanılabilir.

Düzenleyicinizle oluşturduğunuz dosyalara kaynak dosyalar denir ve program kaynak kodunu içerir. Pascal programlarının kaynak dosyaları genellikle şu uzantıyla adlandırılır.pas.

Programlamanıza başlamadan önce, bir metin düzenleyiciniz olduğundan ve bir bilgisayar programı yazmak, onu bir dosyaya kaydetmek, derlemek ve sonunda çalıştırmak için yeterli deneyime sahip olduğunuzdan emin olun.

Pascal programlama dilinin temel yapı taşlarını incelemeden önce, onu gelecek bölümlerde referans olarak alabilmemiz için minimum bir Pascal program yapısına bakalım.

Pascal Program Yapısı

Bir Pascal programı temelde aşağıdaki bölümlerden oluşur -

• Program adı
• Komut kullanır
• Tip bildirimleri
• Sabit beyanlar
• Değişken bildirimleri
• İşlev bildirimleri
• Prosedür beyanları
• Ana program bloğu
• Her blokta İfadeler ve İfadeler
• Comments

Her pascal programın genellikle bir başlık ifadesi, bir bildirimi ve kesinlikle bu sırayla bir yürütme bölümü vardır. Aşağıdaki format, bir Pascal programı için temel sözdizimini gösterir -

program {name of the program}
uses {comma delimited names of libraries you use}
const {global constant declaration block}
var {global variable declaration block}

function {function declarations, if any}
{ local variables }
begin
...
end;

procedure { procedure declarations, if any}
{ local variables }
begin
...
end;

begin { main program block starts}
...
end. { the end of main program block }

Pascal Hello World Örneği

Aşağıda, "Merhaba, Dünya!" Kelimelerini basacak basit bir pascal kod bulunmaktadır. -

program HelloWorld;
uses crt;

(* Here the main program block starts *)
begin
   writeln('Hello, World!');
   readkey;
end.

Bu, aşağıdaki sonucu verecektir -

Hello, World!

Yukarıdaki programın çeşitli bölümlerine bakalım -

• Programın ilk satırı program HelloWorld; programın adını gösterir.

• Programın ikinci satırı uses crt; derleyiciye gerçek derlemeye gitmeden önce crt birimini dahil etmesini söyleyen bir ön işlemci komutudur.

• Başlangıç ​​ve bitiş deyimlerinde yer alan sonraki satırlar ana program bloğudur. Pascal'daki her blok birbegin ifade ve bir endBeyan. Ancak, ana programın sonunu gösteren bitiş ifadesinin ardından noktalı virgül (;) yerine nokta (.) Gelir.

• begin ana program bloğunun ifadesi, program yürütmenin başladığı yerdir.

• İçindeki çizgiler (*...*) derleyici tarafından göz ardı edilecek ve bir comment programda.

• İfade writeln('Hello, World!');Pascal'da bulunan ve "Merhaba, Dünya!" mesajına neden olan writeln işlevini kullanır. ekranda görüntülenecek.

• İfade readkey;kullanıcı bir tuşa basana kadar ekranın duraklamasına izin verir. Crt biriminin bir parçasıdır. Bir birim, Pascal'da bir kitaplık gibidir.

• Son ifade end. programınızı bitirir.

Pascal Programını Derleyin ve Çalıştırın

• Bir metin düzenleyici açın ve yukarıda belirtilen kodu ekleyin.

• Dosyayı hello.pas olarak kaydedin

• Bir komut istemi açın ve dosyayı kaydettiğiniz dizine gidin.

• Komut istemine fpc hello.pas yazın ve kodunuzu derlemek için enter tuşuna basın.

• Kodunuzda hata yoksa, komut istemi sizi bir sonraki satıra götürür ve hello yürütülebilir dosya ve hello.o nesne dosyası.

• Şimdi yazın hello programınızı çalıştırmak için komut isteminde.

• Ekranda "Merhaba Dünya" yazısını görebileceksiniz ve program siz herhangi bir tuşa basana kadar bekler.

$ fpc hello.pas Free Pascal Compiler version 2.6.0 [2011/12/23] for x86_64 Copyright (c) 1993-2011 by Florian Klaempfl and others Target OS: Linux for x86-64 Compiling hello.pas Linking hello 8 lines compiled, 0.1 sec $ ./hello
Hello, World!

Ücretsiz pascal derleyicisinin fpc yolunuzdadır ve hello.pas kaynak dosyasını içeren dizinde çalıştırıyorsunuzdur.

Pascal programının temel bir yapısını gördünüz, bu nedenle pascal programlama dilinin diğer temel yapı taşlarını anlamak kolay olacaktır.

Değişkenler

Bir değişken tanımı, bir var anahtar kelime, ardından aşağıdaki gibi değişkenlerin tanımları gelir:

var
A_Variable, B_Variable ... : Variable_Type;

Pascal değişkenleri, fonksiyonun kod gövdesi dışında bildirilir, bu da onların begin ve end çiftler, ancak prosedür / fonksiyon tanımından sonra ve beginanahtar kelime. Global değişkenler için, program başlığından sonra tanımlanırlar.

Fonksiyonlar / Prosedürler

Pascal'da bir procedure herhangi bir dönüş değeri olmayan ve bir functiondönüş değeri olan bir prosedürdür. İşlev / prosedürlerin tanımı aşağıdaki gibi olacaktır -

Function Func_Name(params...) : Return_Value;
Procedure Proc_Name(params...);

Yorumlar

Çok satırlı yorumlar, süslü parantezler ve yıldız işaretleri (* ... *) şeklinde gösterilir. Pascal, küme parantezleri {...} içine alınmış tek satırlı yoruma izin verir.

(* This is a multi-line comments
   and it will span multiple lines. *)

{ This is a single line comment in pascal }

Büyük küçük harf duyarlılığı

Pascal, büyük / küçük harfe duyarlı olmayan bir dildir; bu, değişkenlerinizi, işlevlerinizi ve prosedürlerinizi her iki durumda da yazabileceğiniz anlamına gelir. A_Variable değişkenleri gibi, a_variable ve A_VARIABLE da Pascal'da aynı anlama sahiptir.

Pascal İfadeleri

Pascal programları ifadelerden oluşur. Her ifade, programın kesin bir işini belirtir. Bu işler bildirim, atama, veri okuma, veri yazma, mantıksal kararlar alma, program akış kontrolünü aktarma vb. Olabilir.

Örneğin -

readln (a, b, c);
s := (a + b + c)/2.0;
area := sqrt(s * (s - a)*(s-b)*(s-c));
writeln(area);

Pascal'da Ayrılmış Kelimeler

Pascal'daki ifadeler, ayrılmış sözcükler olarak adlandırılan bazı özel Pascal sözcükleriyle tasarlanmıştır. Örneğin, program, girdi, çıktı, var, real, begin, readline, writeline ve end sözcüklerinin tümü ayrılmış sözcüklerdir.

Pascal'da bulunan ayrılmış sözcüklerin listesi aşağıdadır.

ve	dizi	başla	durum	sabit
div	yapmak	aşağı	Başka	son
dosya	için	işlevi	git	Eğer
içinde	etiket	mod	sıfır	değil
nın-nin	veya	paketlenmiş	prosedür	program
kayıt	tekrar et	Ayarlamak	sonra	-e
tip	a kadar	var	süre	ile

Pascal'da Karakter Seti ve Tanımlayıcılar

Pascal karakter seti şunlardan oluşur:

• Tüm büyük harfler (AZ)

• Tüm küçük harfler (az)

• Tüm rakamlar (0-9)

• Özel semboller - + * /: =,. ;. () [] = {} `beyaz boşluk

Bir Pascal programındaki değişkenler ve sabitler, türler, işlevler, prosedürler ve kayıtlar gibi varlıklar bir ada veya tanımlayıcıya sahiptir. Tanımlayıcı, bir harfle başlayan bir dizi harf ve rakamdır. Bir tanımlayıcıda özel semboller ve boşluklar kullanılmamalıdır.

Bir varlığın veri türleri, onunla ilişkili anlamı, kısıtlamaları, olası değerleri, işlemleri, işlevleri ve depolama modunu gösterir.

Tam sayı, gerçek, Boole ve karakter türleri standart veri türleri olarak adlandırılır. Veri türleri skaler, işaretçi ve yapılandırılmış veri türleri olarak kategorize edilebilir. Skaler veri türlerinin örnekleri tamsayı, gerçek, Boolean, karakter, alt aralık ve numaralandırılmıştır. Yapılandırılmış veri türleri skaler türlerden yapılır; örneğin diziler, kayıtlar, dosyalar ve kümeler. İşaretçi veri türlerini daha sonra tartışacağız.

Pascal Veri Türleri

Pascal veri türleri aşağıdaki diyagramda özetlenebilir -

Tip Beyanları

Tür bildirimi, bir tanımlayıcının veri türünü bildirmek için kullanılır. Tür bildiriminin sözdizimi -

type-identifier-1, type-identfier-2 = type-specifier;

Örneğin, aşağıdaki bildirim, gün ve yaş değişkenlerini tamsayı türü olarak, evet ve doğru değişkenlerini Boole türü olarak, ad ve şehir dize türü olarak, ücretler ve giderleri gerçek tür olarak tanımlar.

type
days, age = integer;
yes, true = boolean;
name, city = string;
fees, expenses = real;

Tamsayı Türleri

Aşağıdaki tablo, Object Pascal'da kullanılan depolama boyutları ve değer aralıkları ile standart tam sayı türleri hakkında ayrıntılı bilgi verir -

Tür	Minimum	Maksimum	Biçim
Tamsayı	-2147483648	2147483647	32 bit imzalı
Kardinal	0	4294967295	imzasız 32 bit
Shortint	-128	127	8 bit imzalı
Smallint	-32768	32767	16 bit imzalı
Longint	-2147483648	2147483647	32 bit imzalı
Int64	-2 ^ 63	2 ^ 63 - 1	64 bit imzalı
Bayt	0	255	işaretsiz 8 bit
Kelime	0	65535	imzasız 16 bit
Uzun kelime	0	4294967295	imzasız 32 bit

Sabitler

Sabitlerin kullanılması bir programı daha okunabilir hale getirir ve programın başlangıcında özel miktarları tek bir yerde tutmaya yardımcı olur. Pascal sayısal, mantıksal, dizgi ve karakter sabitlerine izin verir . Sabitler, programın bildirim kısmında belirtilerek belirtilebilir.const beyanname.

Sabit tür bildiriminin sözdizimi aşağıdaki gibidir -

const
Identifier = contant_value;

Aşağıda bazı sabit bildirim örnekleri verilmiştir -

VELOCITY_LIGHT = 3.0E=10;
PIE = 3.141592;
NAME = 'Stuart Little';
CHOICE = yes;
OPERATOR = '+';

Tüm sabit bildirimler, değişken bildiriminden önce verilmelidir.

Numaralandırılmış türler

Numaralandırılmış veri türleri, kullanıcı tanımlı veri türleridir. Değerlerin bir listede belirtilmesine izin verirler. Numaralandırılmış veri türünde yalnızca atama operatörlerine ve ilişkisel operatörlere izin verilir. Numaralandırılmış veri türleri aşağıdaki gibi bildirilebilir -

type
enum-identifier = (item1, item2, item3, ... )

Aşağıda, numaralandırılmış tür bildirimlerinin bazı örnekleri verilmiştir -

type
SUMMER = (April, May, June, July, September);
COLORS = (Red, Green, Blue, Yellow, Magenta, Cyan, Black, White);
TRANSPORT = (Bus, Train, Airplane, Ship);

Öğelerin numaralandırılmış bir tür etki alanında listelendiği sıra, öğelerin sırasını tanımlar. Örneğin, numaralandırılmış SUMMER türünde Nisan, Mayıs'tan önce, Mayıs, Haziran'dan önce gelir vb. Numaralandırılmış tür tanımlayıcılarının etki alanı, sayısal veya karakter sabitlerinden oluşamaz.

Alt Aralık Türleri

Alt aralık türleri, bir değişkenin belirli bir aralıkta yer alan değerleri varsaymasına izin verir. Örneğin, seçmenlerin yaşının 18 ila 100 arasında olması gerekiyorsa, yaş adlı bir değişken şu şekilde ilan edilebilir:

var
age: 18 ... 100;

Bir sonraki bölümde değişken bildirimine ayrıntılı olarak bakacağız. Ayrıca tür bildirimini kullanarak bir alt aralık türü de tanımlayabilirsiniz. Bir alt aralık türü bildirmek için sözdizimi aşağıdaki gibidir -

type
subrange-identifier = lower-limit ... upper-limit;

Aşağıda, alt aralık türü bildirimlerinin bazı örnekleri verilmiştir -

const
P = 18;
Q = 90;
type
Number = 1 ... 100;
Value = P ... Q;

Alt aralık türleri, önceden tanımlanmış bir numaralandırılmış türün bir alt kümesinden oluşturulabilir, Örneğin -

type
months = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
Summer = Apr ... Aug;
Winter = Oct ... Dec;

Değişken, programlarımızın değiştirebileceği bir depolama alanına verilen addan başka bir şey değildir. Pascal'daki her değişkenin, değişkenin belleğinin boyutunu ve düzenini belirleyen belirli bir türü vardır; o hafızada saklanabilecek değerlerin aralığı; ve değişkene uygulanabilecek işlemler kümesi.

Bir değişkenin adı harflerden, rakamlardan ve alt çizgi karakterinden oluşabilir. Bir harf veya alt çizgiyle başlamalıdır. Pascalnot case-sensitive, bu nedenle büyük ve küçük harfler burada aynı anlama gelir. Önceki bölümde açıklanan temel türlere göre, aşağıdaki temel değişken türleri olacaktır -

Pascal'da Temel Değişkenler

Sr.No	Tip ve Açıklama
1	Character Genellikle tek bir sekizli (bir bayt). Bu bir tamsayı türüdür.
2	Integer Makine için en doğal tam sayı boyutu.
3	Real Tek duyarlıklı kayan nokta değeri.
4	Boolean Doğru veya yanlış mantıksal değerleri belirtir. Bu aynı zamanda bir tamsayı türüdür.
5	Enumerated Kullanıcı tanımlı bir listeyi belirtir.
6	Subrange Değerleri bir aralık içinde yer alan değişkenleri temsil eder.
7	String Bir dizi karakter saklar.

Pascal programlama dili ayrıca, İşaretçi, Dizi, Kayıtlar, Kümeler ve Dosyalar vb. Gibi sonraki bölümlerde ele alacağımız çeşitli diğer değişken türlerinin tanımlanmasına da izin verir. Bu bölüm için, yalnızca temel değişken türlerini inceleyelim.

Pascal'da Değişken Beyanı

Pascal programında kullanmadan önce tüm değişkenler bildirilmelidir. Tüm değişken bildirimlerinin ardından var anahtar sözcüğü gelir. Bir bildirim, değişkenlerin bir listesini, ardından iki nokta üst üste (:) ve türü belirtir. Değişken bildiriminin sözdizimi -

var
variable_list : type;

Burada tür, karakter, tamsayı, gerçek, boole veya herhangi bir kullanıcı tanımlı veri türü dahil olmak üzere geçerli bir Pascal veri türü olmalıdır ve değişken_listesi virgülle ayrılmış bir veya daha fazla tanımlayıcı adından oluşabilir. Bazı geçerli değişken açıklamaları burada gösterilmektedir -

var
age, weekdays : integer;
taxrate, net_income: real;
choice, isready: boolean;
initials, grade: char;
name, surname : string;

Önceki eğitimde, Pascal'ın bir tür bildirmeye izin verdiğini tartışmıştık. Bir tür, bir ad veya tanımlayıcıyla tanımlanabilir. Bu tür, bu türdeki değişkenleri tanımlamak için kullanılabilir. Örneğin,

type
days, age = integer;
yes, true = boolean;
name, city = string;
fees, expenses = real;

Şimdi, bu şekilde tanımlanan türler değişken bildirimlerinde kullanılabilir -

var
weekdays, holidays : days;
choice: yes;
student_name, emp_name : name;
capital: city;
cost: expenses;

Lütfen tip beyanı ile var beyanı arasındaki farka dikkat edin . Tür bildirimi, tam sayı, gerçek vb. Türlerin kategorisini veya sınıfını belirtirken, değişken özelliği bir değişkenin alabileceği değerlerin türünü belirtir. Pascal'daki tür bildirimini C'deki typedef ile karşılaştırabilirsiniz . En önemlisi, değişken adı, değişkenin değerinin depolanacağı bellek konumunu belirtir. Tip bildiriminde durum böyle değildir.

Pascal'da Değişken Başlatma

Değişkenlere iki nokta üst üste ve eşittir işaretiyle bir değer atanır, ardından sabit bir ifade gelir. Bir değer atamanın genel şekli -

variable_name := value;

Varsayılan olarak, Pascal'daki değişkenler sıfır ile başlatılmaz. Çöp değerleri içerebilirler. Bu nedenle, bir programdaki değişkenleri başlatmak daha iyi bir uygulamadır. Değişkenler bildirimlerinde başlatılabilir (bir başlangıç ​​değeri atanabilir). Başlatma işleminin ardındanvar anahtar kelime ve başlatma sözdizimi aşağıdaki gibidir -

var
variable_name : type = value;

Bazı örnekler -

age: integer = 15;
taxrate: real = 0.5;
grade: char = 'A';
name: string = 'John Smith';

Şimdiye kadar tartışılan çeşitli değişken türlerini kullanan bir örneğe bakalım -

program Greetings;
const
message = ' Welcome to the world of Pascal ';

type
name = string;
var
firstname, surname: name;

begin
   writeln('Please enter your first name: ');
   readln(firstname);
   
   writeln('Please enter your surname: ');
   readln(surname);
   
   writeln;
   writeln(message, ' ', firstname, ' ', surname);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Please enter your first name:
John
Please enter your surname:
Smith
Welcome to the world of Pascal John Smith

Numaralandırılmış Değişkenler

Tam sayı, gerçek ve boole gibi basit değişken türlerini nasıl kullanacağınızı gördünüz. Şimdi, - olarak tanımlanabilecek numaralandırılmış tip değişkenleri görelim.

var
var1, var2, ...  : enum-identifier;

Numaralandırılmış bir tür bildirdiğinizde, bu türdeki değişkenleri bildirebilirsiniz. Örneğin,

type
months = (January, February, March, April, May, June, July, August, September, October, November, December);
Var
m: months;
...
M := January;

Aşağıdaki örnek kavramı göstermektedir -

program exEnumeration;
type
beverage = (coffee, tea, milk, water, coke, limejuice);

var
drink:beverage;

begin
   writeln('Which drink do you want?');
   drink := limejuice;
   
   writeln('You can drink ', drink);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Which drink do you want?
You can drink limejuice

Alt Aralık Değişkenleri

Alt aralık değişkenleri şu şekilde bildirilir -

var
subrange-name : lowerlim ... uperlim;

Alt aralık değişkenlerinin örnekleri -

var
marks: 1 ... 100;
grade: 'A' ... 'E';
age: 1 ... 25;

Aşağıdaki program kavramı göstermektedir -

program exSubrange;
var
marks: 1 .. 100;
grade: 'A' .. 'E';

begin
   writeln( 'Enter your marks(1 - 100): ');
   readln(marks);
   
   writeln( 'Enter your grade(A - E): ');
   readln(grade);
   
   writeln('Marks: ' , marks, ' Grade: ', grade);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter your marks(1 - 100): 
100
Enter your grade(A - E):
A
Marks: 100 Grade: A

Sabit, programın yürütülmesi sırasında değişmeden kalan bir varlıktır. Pascal, yalnızca aşağıdaki türlerdeki sabitlerin beyan edilmesine izin verir -

• Sıra türleri
• Türleri ayarla
• İşaretçi türleri (ancak izin verilen tek değer Nil'dir).
• Gerçek türler
• Char
• String

Sabitleri Bildirme

Sabitleri bildirmek için sözdizimi aşağıdaki gibidir -

const
identifier = constant_value;

Aşağıdaki tablo, bazı geçerli sabit bildirimlerin örneklerini sunar -

Real type constant

Sr.No	Sabit Tip ve Örnekler
1	Ordinal(Integer)type constant valid_age = 21;
2	Set type constant Ünlüler = (A, E, I, O, U) kümesi;
3	Pointer type constant P = NIL;
4	e = 2.7182818; velocity_light = 3.0E + 10;
5	Character type constant Operatör = '+';
6	String type constant başkan = 'Johnny Depp';

Aşağıdaki örnek kavramı göstermektedir -

program const_circle (input,output);
const
PI = 3.141592654;

var
r, d, c : real;   {variable declaration: radius, dia, circumference}

begin
   writeln('Enter the radius of the circle');
   readln(r);
   
   d := 2 * r;
   c :=  PI * d;
   writeln('The circumference of the circle is ',c:7:2);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter the radius of the circle
23
The circumference of the circle is 144.51

Programın çıktı deyimindeki biçimlendirmeye dikkat edin. Değişken c, ondalık işaretinden sonra 7 ve 2 basamaklı toplam rakamlarla formatlanmalıdır. Pascal, sayısal değişkenlerle bu tür çıktı biçimlendirmesine izin verir.

Operatör, derleyiciye belirli matematiksel veya mantıksal işlemleri gerçekleştirmesini söyleyen bir semboldür. Pascal, aşağıdaki operatör türlerine izin verir -

• Aritmetik operatörler
• İlişkisel operatörler
• Boole operatörleri
• Bit operatörleri
• Operatörleri ayarla
• Dize operatörleri

Aritmetik, ilişkisel, Boole ve bit operatörlerini tek tek tartışalım. Set operatörlerini ve dizgi işlemlerini daha sonra tartışacağız.

Aritmetik operatörler

Aşağıdaki tablo, Pascal tarafından desteklenen tüm aritmetik operatörleri göstermektedir. Değişken varsayA 10 ve değişken tutar B 20 tutar, sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
+	İki işlenen ekler	A + B 30 verecek
-	İlk işlenenden ikinci işleneni çıkarır	A - B -10 verir
*	Her iki işleneni de çarpar	A * B 200 verecek
/	Payı paydaya böler	B / A 2 verecek
%	Modül İşleci ve bir tamsayı bölmesinden sonra kalanı	B% A 0 verir

İlişkisel Operatörler

Aşağıdaki tablo, Pascal tarafından desteklenen tüm ilişkisel operatörleri göstermektedir. Değişken varsayA 10 ve değişken tutar B 20 tutar, sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
=	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A = B) doğru değil.
<>	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder, değerler eşit değilse koşul doğru olur.	(A <> B) doğrudur.
>	Sol işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A> B) doğru değil.
<	Left operand değerinin right operand değerinden küçük olup olmadığını kontrol eder, eğer evet ise, o zaman koşul doğru olur.	(A <B) doğrudur.
> =	Soldaki işlenenin değerinin sağ işlenenin değerinden büyük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A> = B) doğru değil.
<=	Sol işlenenin değerinin sağ işlenenin değerinden küçük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A <= B) doğrudur.

Boole Operatörleri

Aşağıdaki tablo, Pascal dili tarafından desteklenen tüm Boole operatörlerini göstermektedir. Tüm bu operatörler Boole işlenenleri üzerinde çalışır ve Boolean sonuçları üretir. Değişken varsayA doğru ve değişken tutar B yanlış tutar, o zaman -

Örnekleri Göster

Şebeke	Açıklama	Misal
ve	Boolean AND operatörü olarak adlandırılır. Her iki işlenen de doğruysa koşul doğru olur.	(A ve B) yanlıştır.
ve sonra	AND işlecine benzer, ancak, derleyicinin mantıksal ifadeyi değerlendirme sırasını garanti eder. Soldan sağa ve sağ işlenenler yalnızca gerekli olduğunda değerlendirilir.	(A ve sonra B) yanlıştır.
veya	Boole VEYA Operatörü olarak adlandırılır. İki işlenenden herhangi biri doğruysa, koşul doğru olur.	(A veya B) doğrudur.
ya da başka	Boole VEYA'ya benzer, ancak, derleyicinin mantıksal ifadeyi değerlendireceği sırayı garanti eder. Soldan sağa ve sağ işlenenler yalnızca gerekli olduğunda değerlendirilir.	(A veya B) doğrudur.
değil	Boolean NOT Operatörü olarak adlandırıldı. İşlenenin mantıksal durumunu tersine çevirmek için kullanılır. Bir koşul doğruysa, Mantıksal NOT operatörü onu yanlış yapar.	değil (A ve B) doğru değil.

Bit Operatörleri

Bitsel operatörler bitler üzerinde çalışır ve bit bit işlem gerçekleştirir. Tüm bu operatörler tamsayı işlenenler üzerinde çalışır ve tamsayı sonuçlar üretir. Bitsel ve (&), bitsel veya (|) ve bitsel değil (~) için doğruluk tablosu aşağıdaki gibidir -

p	q	p & q	p | q	~ p	~ q
0	0	0	0	1	1
0	1	0	1	1	0
1	1	1	1	0	0
1	0	0	1	0	1

A = 60 ise; ve B = 13; şimdi ikili biçimde aşağıdaki gibi olacaklar -

Bir = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A ^ B = 0011 0001

~ A = 1100 0011

Pascal tarafından desteklenen Bitwise operatörleri aşağıdaki tabloda listelenmiştir. A değişkeninin 60 ve B değişkeninin 13 olduğunu varsayın, o zaman:

Örnekleri Göster

Şebeke	Açıklama	Misal
&	İkili VE İşleci, her iki işlenende de varsa sonuca bir bit kopyalar.	(A & B) 0000 1100 olan 12 verecek
|	İkili VEYA İşleci, işlenenlerden herhangi birinde varsa bir bit kopyalar.	(A | B), 0011 1101 olan 61 verecek
!	İkili VEYA İşleci, işlenenlerden herhangi birinde varsa bir bit kopyalar. Aynı | Şebeke.	(A! B) 0011 1101 olan 61 verecek
~	İkili Birler Tamamlayıcı Operatörü tekli ve bitleri 'çevirme' etkisine sahiptir.	(~ A), işaretli bir ikili sayı nedeniyle 2'nin tamamlayıcı formunda 1100 0011 olan -61'i verecektir.
<<	İkili Sol Kaydırma Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sola taşınır.	Bir << 2 240 verir, yani 1111 0000
>>	İkili Sağ Shift Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sağa taşınır.	A >> 2, 0000 1111 olan 15 verir

Lütfen Pascal'ın farklı uygulamalarının bitsel işleçlerde farklılık gösterdiğini unutmayın. Ancak burada kullandığımız derleyici Free Pascal, aşağıdaki bitsel operatörleri destekler -

Operatörler	Operasyonlar
değil	Bitsel DEĞİL
ve	Bitsel AND
veya	Bit tabanlı VEYA
Xor	Bit düzeyinde özel VEYA
shl	Bit tabanlı sola kaydırma
shr	Bit tabanlı sağa kaydırma
<<	Bit tabanlı sola kaydırma
>>	Bit tabanlı sağa kaydırma

Pascal'da Operatör Önceliği

Operatör önceliği, bir ifadedeki terimlerin gruplandırılmasını belirler. Bu, bir ifadenin nasıl değerlendirileceğini etkiler. Bazı operatörler diğerlerinden daha yüksek önceliğe sahiptir; örneğin, çarpma operatörü toplama operatöründen daha yüksek önceliğe sahiptir.

Örneğin x = 7 + 3 * 2; burada, x operatörü + 'dan daha yüksek önceliğe sahip olduğu için 20 değil, 13 atanır, bu nedenle önce 3 * 2 ile çarpılır ve sonra 7'ye eklenir.

Burada, en yüksek önceliğe sahip operatörler tablonun en üstünde, en düşük olanlar ise en altta görünür. Bir ifade içinde, daha yüksek öncelikli operatörler ilk olarak değerlendirilecektir.

Örnekleri Göster

Şebeke	Öncelik
~, hayır,	En yüksek
*, /, div, mod ve &
|,!, +, - veya,
=, <>, <, <=,>,> =, içinde
veya başka türlü ve sonra	En düşük

Karar verme yapıları, programcının, program tarafından değerlendirilecek veya test edilecek bir veya daha fazla koşulu, koşulun doğru olduğu belirlenirse yürütülecek bir ifade veya ifadeyle birlikte belirtmesini ve isteğe bağlı olarak, koşulun doğru olması durumunda yürütülecek diğer ifadeleri gerektirir. yanlış olduğu belirlenir.

Aşağıda, programlama dillerinin çoğunda bulunan tipik bir karar verme yapısının genel biçimi verilmiştir -

Pascal programlama dili aşağıdaki türden karar verme ifadelerini sağlar. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.

Sr.No	Açıklama ve Açıklama
1	eğer - sonra ifadesi Bir if - then statement bir boole ifadesinin ardından bir veya daha fazla ifadeden oluşur.
2	If-then-else ifadesi Bir if - then statement ardından isteğe bağlı bir else statement, boolean ifadesi yanlış olduğunda çalıştırılır.
3	yuvalanmış if ifadeleri Birini kullanabilirsin if veya else if bir başkasının içinde ifade if veya else if beyan (lar).
4	vaka beyanı Bir case ifadesi, bir değişkenin bir değerler listesine karşı eşitlik açısından test edilmesine izin verir.
5	case - else ifadesi Şuna benzer if-then-else Beyan. Burada, birelse terim takip eder case statement.
6	iç içe geçmiş durum ifadeleri Birini kullanabilirsin case bir başkasının içinde ifade case beyan (lar).

Bir kod bloğunu birkaç kez çalıştırmanız gereken bir durum olabilir. Genel olarak, ifadeler sıralı olarak yürütülür: Bir fonksiyondaki ilk ifade önce çalıştırılır, ardından ikincisi vb.

Programlama dilleri, daha karmaşık yürütme yollarına izin veren çeşitli kontrol yapıları sağlar.

Bir döngü deyimi, bir deyimi veya deyim grubunu birden çok kez yürütmemize olanak tanır ve aşağıdaki programlama dillerinin çoğunda bir döngü deyiminin genel biçimidir -

Pascal programlama dili, döngü gereksinimlerini karşılamak için aşağıdaki döngü yapı türlerini sağlar. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.

Sr.No	Döngü Tipi ve Açıklaması
1	while-do döngüsü Belirli bir koşul doğruyken bir ifadeyi veya ifade grubunu tekrarlar. Döngü gövdesini çalıştırmadan önce koşulu test eder.
2	for-do döngüsü Bir dizi ifadeyi birden çok kez yürütür ve döngü değişkenini yöneten kodu kısaltır.
3	dönene kadar tekrar et Döngü gövdesinin sonundaki koşulu test etmesi dışında bir while ifadesi gibi.
4	İç içe geçmiş döngüler Bir veya daha fazla döngüyü diğerinin içinde, döngü için veya döngüye kadar tekrarlayabilirsiniz.

Döngü Kontrol İfadeleri

Döngü kontrol ifadeleri, yürütmeyi normal sırasından değiştirir. Yürütme bir kapsam bıraktığında, bu kapsamda oluşturulan tüm otomatik nesneler yok edilir.

Pascal aşağıdaki kontrol ifadelerini destekler. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.

Sr.No	Kontrol İfadesi ve Açıklama
1	break ifadesi Sonlandırır loop veya case ifadesi ve yürütmeyi döngü veya case ifadesinin hemen ardından ifadeye aktarır.
2	devam ifadesi Döngünün vücudunun geri kalanını atlamasına ve yinelemeden önce durumunu hemen yeniden test etmesine neden olur.
3	git beyanı Kontrolü etiketli ifadeye aktarır. Programınızda goto ifadesini kullanmanız önerilmez.

Alt programlar

Bir alt program, belirli bir görevi yerine getiren bir program birimi / modülüdür. Bu alt programlar, daha büyük programlar oluşturmak için birleştirilir. Bu temelde 'Modüler tasarım' olarak adlandırılır. Bir alt program, çağıran program olarak adlandırılan bir alt program / program tarafından çalıştırılabilir.

Pascal iki tür alt program sağlar -

• Functions - bu alt programlar tek bir değer döndürür.

• Procedures - bu alt programlar doğrudan bir değer döndürmez.

Fonksiyonlar

Bir functionbirlikte bir görevi yerine getiren bir grup ifadedir. Her Pascal programının, programın kendisi olan en az bir işlevi vardır ve en önemsiz programların tümü ek işlevleri tanımlayabilir.

Bir işlev declarationderleyiciye bir işlevin adı, dönüş türü ve parametreleri hakkında bilgi verir. Bir işlevdefinition işlevin gerçek gövdesini sağlar.

Pascal standart kitaplığı, programınızın çağırabileceği çok sayıda yerleşik işlev sağlar. Örneğin, işlevAppendStr() iki dizge ekler, fonksiyon New() dinamik olarak bellekleri değişkenlere ve daha birçok işleve tahsis eder.

Bir Fonksiyonun Tanımlanması

Pascal'da bir functionfunction anahtar sözcüğü kullanılarak tanımlanır. Bir fonksiyon tanımının genel biçimi aşağıdaki gibidir -

function name(argument(s): type1; argument(s): type2; ...): function_type;
local declarations;

begin
   ...
   < statements >
   ...
   name:= expression;
end;

Pascal'daki bir fonksiyon tanımı bir fonksiyondan oluşur header, yerel declarations ve bir işlev body. İşlev başlığı, anahtar sözcük işlevinden ve birnameişleve verilir. İşte bir fonksiyonun tüm bölümleri -

• Arguments- Bağımsız değişken (ler), çağıran program ile işlev tanımlayıcıları arasındaki bağlantıyı kurar ve ayrıca biçimsel parametreler olarak da adlandırılır. Parametre, yer tutucu gibidir. Bir işlev çağrıldığında, parametreye bir değer iletirsiniz. Bu değere gerçek parametre veya bağımsız değişken adı verilir. Parametre listesi, bir işlevin türü, sırası ve parametrelerinin sayısı ile ilgilidir. Bu tür biçimsel parametrelerin kullanımı isteğe bağlıdır. Bu parametreler standart veri tipine, kullanıcı tanımlı veri tipine veya alt aralık veri tipine sahip olabilir.

  İşlev deyiminde görünen biçimsel parametreler listesi, basit veya alt simgeli değişkenler, diziler veya yapılandırılmış değişkenler veya alt programlar olabilir.

• Return Type- Tüm işlevler bir değer döndürmelidir, bu nedenle tüm işlevlere bir tür atanmalıdır. function-typeişlevin döndürdüğü değerin veri türüdür. Standart, kullanıcı tanımlı skaler veya alt aralık tipi olabilir, ancak yapılandırılmış tip olamaz.

• Local declarations - Yerel bildirimler, yalnızca işlev gövdesine uygulanan etiketler, sabitler, değişkenler, işlevler ve prosedürler için bildirimlere atıfta bulunur.

• Function Body- İşlev gövdesi, işlevin ne yaptığını tanımlayan bir dizi deyim içerir. Her zaman ayrılmış sözcüklerin başlangıcı ve bitişi arasına alınmalıdır. Tüm hesaplamaların yapıldığı bir işlevin parçasıdır. Türünde bir atama ifadesi olmalıdır -name := expression;işlev adına bir değer atayan işlev gövdesinde. Bu değer, işlev çalıştırıldığında döndürülür. Gövdedeki son ifade bir son ifade olmalıdır.

Aşağıda, bir fonksiyonun pascal olarak nasıl tanımlanacağını gösteren bir örnek verilmiştir -

(* function returning the max between two numbers *)
function max(num1, num2: integer): integer;

var
   (* local variable declaration *)
   result: integer;

begin
   if (num1 > num2) then
      result := num1
   
   else
      result := num2;
   max := result;
end;

İşlev Bildirimleri

Bir işlev declarationderleyiciye bir işlev adı ve işlevin nasıl çağrılacağını anlatır. Fonksiyonun gerçek gövdesi ayrı ayrı tanımlanabilir.

Bir işlev bildirimi aşağıdaki bölümlerden oluşur -

function name(argument(s): type1; argument(s): type2; ...): function_type;

Yukarıda tanımlanan max () fonksiyonu için, fonksiyon bildirimi aşağıdadır -

function max(num1, num2: integer): integer;

Bir kaynak dosyada bir işlev tanımladığınızda ve bu işlevi başka bir dosyada çağırdığınızda işlev bildirimi gereklidir. Böyle bir durumda, işlevi çağıran dosyanın en üstünde işlevi bildirmelisiniz.

Bir Fonksiyon Çağırma

Bir işlev oluştururken, işlevin ne yapması gerektiğine dair bir tanım verirsiniz. Bir işlevi kullanmak için, tanımlanan görevi gerçekleştirmek üzere o işlevi çağırmanız gerekir. Bir program bir işlevi çağırdığında, program kontrolü çağrılan işleve aktarılır. Çağrılan bir işlev tanımlanmış görevi yerine getirir ve return ifadesi yürütüldüğünde veya son bitiş ifadesine ulaşıldığında, program kontrolünü ana programa geri döndürür.

Bir işlevi çağırmak için, gerekli parametreleri işlev adıyla birlikte iletmeniz yeterlidir ve işlev bir değer döndürürse, döndürülen değeri saklayabilirsiniz. Aşağıda, kullanımı göstermek için basit bir örnek verilmiştir -

program exFunction;
var
   a, b, ret : integer;

(*function definition *)
function max(num1, num2: integer): integer;
var
   (* local variable declaration *)
   result: integer;

begin
   if (num1 > num2) then
      result := num1
   
   else
      result := num2;
   max := result;
end;

begin
   a := 100;
   b := 200;
   (* calling a function to get max value *)
   ret := max(a, b);
   
   writeln( 'Max value is : ', ret );
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Max value is : 200

Procedures tek bir değer döndürmek yerine bir grup sonuç elde etmeyi sağlayan alt programlardır.

Bir Prosedür Tanımlama

Pascal'da, bir prosedür kullanılarak tanımlanır procedureanahtar kelime. Bir prosedür tanımının genel biçimi aşağıdaki gibidir -

procedure name(argument(s): type1, argument(s): type 2, ... );
   < local declarations >
begin
   < procedure body >
end;

Prosedür definition Pascal'da bir header, yerel declarations ve bir bodyprosedürün. Prosedür başlığı anahtar kelimeden oluşurprocedureve prosedüre verilen bir isim. İşte bir prosedürün tüm bölümleri -

• Arguments- Argüman (lar), çağıran program ile prosedür tanımlayıcıları arasındaki bağlantıyı kurar ve ayrıca biçimsel parametreler olarak da adlandırılır. Prosedürlerde argümanların kuralları, fonksiyonlar için olanla aynıdır.

• Local declarations - Yerel bildirimler, yalnızca prosedürün gövdesi için geçerli olan etiketler, sabitler, değişkenler, işlevler ve prosedürler için bildirimlere atıfta bulunur.

• Procedure Body- Prosedür gövdesi, prosedürün ne yaptığını tanımlayan bir dizi ifadeler içerir. Her zaman ayrılmış sözcüklerin başlangıcı ve bitişi arasına alınmalıdır. Tüm hesaplamaların yapıldığı bir prosedürün parçasıdır.

Aşağıda findMin () adlı bir prosedürün kaynak kodu verilmiştir . Bu prosedür, 4 x, y, z ve m parametresini alır ve m adlı değişkendeki ilk üç değişken arasındaki minimum değerleri saklar. M değişkeni tarafından geçilirreference (geçen argümanları biraz sonra referans alarak tartışacağız) -

procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m := x
   else
      m := y;
   
   if z <m then
      m := z;
end; { end of procedure findMin }

Prosedür Beyanları

Prosedür declarationderleyiciye bir prosedür adı ve prosedürün nasıl çağrılacağını anlatır. Prosedürün gerçek gövdesi ayrı ayrı tanımlanabilir.

Bir prosedür bildirimi aşağıdaki sözdizimine sahiptir -

procedure name(argument(s): type1, argument(s): type 2, ... );

Lütfen unutmayın name of the procedure is not associated with any type. Yukarıda tanımlanan prosedür için findMin () , aşağıdaki bildirimdir -

procedure findMin(x, y, z: integer; var m: integer);

Prosedürü Çağırma

Bir prosedür oluştururken, prosedürün ne yapması gerektiğine dair bir tanım verirsiniz. Prosedürü kullanmak için, tanımlanan görevi gerçekleştirmek için bu prosedürü çağırmanız gerekecektir. Bir program bir prosedürü çağırdığında, program kontrolü çağrılan prosedüre aktarılır. Çağrılan bir prosedür, tanımlanan görevi gerçekleştirir ve son bitiş ifadesine ulaşıldığında, kontrolü çağıran programa geri döndürür.

Bir prosedürü çağırmak için, aşağıda gösterildiği gibi prosedür adıyla birlikte gerekli parametreleri iletmeniz yeterlidir -

program exProcedure;
var
   a, b, c,  min: integer;
procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m:= x
   else
      m:= y;
   
   if z < m then
      m:= z;
end; { end of procedure findMin }  

begin
   writeln(' Enter three numbers: ');
   readln( a, b, c);
   findMin(a, b, c, min); (* Procedure call *)
   
   writeln(' Minimum: ', min);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter three numbers:
89 45 67
Minimum: 45

Yinelemeli Alt Programlar

Bir programın veya alt programın başka bir alt programı çağırabileceğini gördük. Bir alt program kendisini çağırdığında, buna özyinelemeli arama denir ve süreç özyineleme olarak bilinir.

Kavramı açıklamak için bir sayının faktöriyelini hesaplayalım. Bir sayının faktöriyeli n olarak tanımlanır -

n! = n*(n-1)!
   = n*(n-1)*(n-2)!
      ...
   = n*(n-1)*(n-2)*(n-3)... 1

Aşağıdaki program kendini yinelemeli olarak arayarak belirli bir sayının faktöriyelini hesaplar.

program exRecursion;
var
   num, f: integer;
function fact(x: integer): integer; (* calculates factorial of x - x! *)

begin
   if x=0 then
      fact := 1
   else
      fact := x * fact(x-1); (* recursive call *)
end; { end of function fact}

begin
   writeln(' Enter a number: ');
   readln(num);
   f := fact(num);
   
   writeln(' Factorial ', num, ' is: ' , f);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter a number:
5
Factorial 5 is: 120

Aşağıda, oluşturan başka bir örnek yer almaktadır. Fibonacci Series kullanarak belirli bir sayı için recursive işlev -

program recursiveFibonacci;
var
   i: integer;
function fibonacci(n: integer): integer;

begin
   if n=1 then
      fibonacci := 0
   
   else if n=2 then
      fibonacci := 1
   
   else
      fibonacci := fibonacci(n-1) + fibonacci(n-2);
end; 

begin
   for i:= 1 to 10 do
   
   write(fibonacci (i), '  ');
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

0 1 1 2	3 5 8 13 21 34

Bir Alt Programın Argümanları

Bir alt program (function or procedure) argümanlar kullanmaktır, argümanların değerlerini kabul eden değişkenleri bildirmelidir. Bu değişkenlereformal parameters alt programın.

Biçimsel parametreler, alt program içindeki diğer yerel değişkenler gibi davranır ve alt programa girişte oluşturulur ve çıkışta yok edilir.

Bir alt programı çağırırken, argümanların alt programa aktarılmasının iki yolu vardır:

Sr.No	Çağrı Tipi ve Açıklaması
1	Değere göre ara Bu yöntem bir bağımsız değişkenin gerçek değerini alt programın biçimsel parametresine kopyalar. Bu durumda, alt program içindeki parametrede yapılan değişikliklerin bağımsız değişken üzerinde hiçbir etkisi yoktur.
2	Referansla arayın Bu yöntem, bir argümanın adresini biçimsel parametreye kopyalar. Alt programın içinde adres, çağrıda kullanılan asıl argümana erişmek için kullanılır. Bu, parametrede yapılan değişikliklerin bağımsız değişkeni etkilediği anlamına gelir.

Pascal, varsayılan olarak call by valueargümanlar iletmek için. Genel olarak bu, bir alt program içindeki kodun, alt programı çağırmak için kullanılan argümanları değiştiremeyeceği anlamına gelir. 'Pascal - Fonksiyonlar' bölümünde kullandığımız örnek program, şunu kullanarak max () adlı işlevi çağırdıcall by value.

Burada sağlanan örnek program ( exProcedure ) ise findMin () prosedürünü kullanarakcall by reference.

Herhangi bir programlamadaki kapsam, programın tanımlanmış bir değişkenin var olabileceği ve bu değişkenin ötesine erişilemeyen bir bölgesidir. Değişkenlerin Pascal programlama dilinde bildirilebileceği üç yer vardır -

• Yerel değişkenler olarak adlandırılan bir alt programın veya bloğun içinde

• Global değişkenler olarak adlandırılan tüm alt programların dışında

• Biçimsel parametreler olarak adlandırılan alt program parametrelerinin tanımında

Ne olduğunu açıklayalım local ve global değişkenler ve biçimsel parametreler.

Yerel Değişkenler

Bir alt program veya blok içinde bildirilen değişkenlere yerel değişkenler denir. Yalnızca bu alt programın veya kod bloğunun içindeki ifadeler tarafından kullanılabilirler. Yerel değişkenler, kendi alt programları dışında bilinmemektedir. Aşağıda yerel değişkenlerin kullanıldığı örnek verilmiştir. Burada, tüm a , b ve c değişkenleri exLocal adlı program için yereldir .

program exLocal; 
var
   a, b, c: integer;

begin
   (* actual initialization *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

value of a = 10 b = 20 c = 30

Şimdi, programı biraz daha genişletelim, kendi a , b ve c değişkenlerine sahip olacak ve değerlerini doğrudan exLocal programından gösterecek display adında bir prosedür oluşturalım .

program exLocal;
var
   a, b, c: integer;
procedure display;

var
   a, b, c: integer;
begin
   (* local variables *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln('Winthin the procedure display');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
end;

begin
   a:= 100;
   b:= 200;
   c:= a + b;
   
   writeln('Winthin the program exlocal');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   display();
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
value of a = 10 b = 20 c = 30

Global Değişkenler

Global değişkenler, bir fonksiyonun dışında, genellikle programın üstünde tanımlanır. Global değişkenler, programınızın ömrü boyunca değerlerini koruyacak ve program için tanımlanan işlevlerden herhangi birinin içinden erişilebilir.

Bir globaldeğişkenine herhangi bir işlevle erişilebilir. Diğer bir deyişle, global bir değişken, bildiriminden sonra tüm programınız boyunca kullanılabilir. Aşağıdaki kullanan bir örnekglobal ve local değişkenler -

program exGlobal;
var
   a, b, c: integer;
procedure display;
var
   x, y, z: integer;

begin
   (* local variables *)
   x := 10;
   y := 20;
   z := x + y;
   
   (*global variables *)
   a := 30;
   b:= 40;
   c:= a + b;
   
   writeln('Winthin the procedure display');
   writeln(' Displaying the global variables a, b, and c');
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   writeln('Displaying the local variables x, y, and z');
   
   writeln('value of x = ', x , ' y =  ',  y, ' and z = ', z);
end;

begin
   a:= 100;
   b:= 200;
   c:= 300;
   
   writeln('Winthin the program exlocal');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   
   display();
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
Displaying the global variables a, b, and c
value of a = 30 b = 40 c = 70
Displaying the local variables x, y, and z
value of x = 10 y = 20 z = 30

Prosedür görüntüsünün, ekrana göre global değişkenler ve kendi yerel değişkenleri olan a, b ve c değişkenlerine erişimi olduğunu lütfen unutmayın. Bir program yerel ve global değişkenler için aynı isme sahip olabilir, ancak bir fonksiyon içindeki yerel değişkenin değeri tercih edilir.

Önceki örneği biraz değiştirelim, şimdi prosedür görüntüsünün yerel değişkenleri a , b , c ile aynı adlara sahip -

program exGlobal;
var
   a, b, c: integer;
procedure display;

var
   a, b, c: integer;

begin
   (* local variables *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln('Winthin the procedure display');
   writeln(' Displaying the global variables a, b, and c');
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
   writeln('Displaying the local variables a, b, and c');
   
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);
end;

begin
   a:= 100;
   b:= 200;
   c:= 300;
   
   writeln('Winthin the program exlocal');
   writeln('value of a = ', a , ' b =  ',  b, ' and c = ', c);   
   
   display();
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
Displaying the global variables a, b, and c
value of a = 10 b = 20 c = 30
Displaying the local variables a, b, and c
value of a = 10 b = 20 c = 30

Pascal'daki dizge aslında isteğe bağlı bir boyut belirtimine sahip bir karakter dizisidir. Karakterler sayısal, harfler, boş, özel karakterler veya hepsinin bir kombinasyonu olabilir. Extended Pascal, sisteme ve uygulamaya bağlı olarak çok sayıda dizi nesnesi sağlar. Programlarda kullanılan daha yaygın dizge türlerini tartışacağız.

Bir dizeyi birçok şekilde tanımlayabilirsiniz -

• Character arrays - Bu, tek tırnak içine alınmış, sıfır veya daha fazla bayt boyutlu karakter dizisi olan bir karakter dizisidir.

• String variables - Turbo Pascal'da tanımlandığı şekliyle String türü değişkeni.

• Short strings - Boyut spesifikasyonuna sahip Dize türü değişkeni.

• Null terminated strings - değişkeni pchar yazın.

• AnsiStrings - Ansistringler, uzunluk sınırı olmayan dizelerdir.

Pascal yalnızca bir dize operatörü, dize birleştirme operatörü (+) sağlar.

Örnekler

Aşağıdaki program ilk dört tür dizeyi yazdırır. Bir sonraki örnekte AnsiStrings kullanacağız.

program exString;
var
   greetings: string;
   name: packed array [1..10] of char;
   organisation: string[10];
   message: pchar;

begin
   greetings := 'Hello ';
   message := 'Good Day!';
   
   writeln('Please Enter your Name');
   readln(name);
   
   writeln('Please Enter the name of your Organisation');
   readln(organisation);
   
   writeln(greetings, name, ' from ', organisation);
   writeln(message); 
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Please Enter your Name
John Smith
Please Enter the name of your Organisation
Infotech
Hello John Smith from Infotech

Aşağıdaki örnek birkaç işlevi daha kullanıyor, bakalım -

program exString;
uses sysutils;
var
   str1, str2, str3 : ansistring;
   str4: string;
   len: integer;

begin
   str1 := 'Hello ';
   str2 := 'There!';
   
   (* copy str1 into str3 *)
   str3 := str1;
   writeln('appendstr( str3, str1) :  ', str3 );
   
   (* concatenates str1 and str2 *)
   appendstr( str1, str2);
   writeln( 'appendstr( str1, str2) ' , str1 );
   str4 := str1 + str2;
   writeln('Now str4 is: ', str4);
   
   (* total lenghth of str4 after concatenation  *)
   len := byte(str4[0]);
   writeln('Length of the final string str4: ', len); 
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

appendstr( str3, str1) : Hello
appendstr( str1, str2) : Hello There!
Now str4 is: Hello There! There!
Length of the final string str4: 18

Pascal String Fonksiyonları ve Prosedürleri

Pascal, dizeleri işleyen çok çeşitli işlevleri ve prosedürleri destekler. Bu alt programlar uygulama açısından farklılık gösterir. Burada, Free Pascal tarafından sağlanan çeşitli dizge işleyen alt programları listeliyoruz -

Sr.No.	İşlev ve Amaç
1	function AnsiCompareStr(const S1: ; const S2:):Integer; İki dizeyi karşılaştırır
2	function AnsiCompareText(const S1: ; const S2:):Integer; Büyük / küçük harfe duyarlı olmayan iki dizeyi karşılaştırır
3	function AnsiExtractQuotedStr(var Src: PChar; Quote: Char):; Dizeden tırnakları kaldırır
4	function AnsiLastChar(const S:):PChar; Dizenin son karakterini alır
5	function AnsiLowerCase(const s:): Dizeyi tamamen küçük harfe dönüştürür
6	function AnsiQuotedStr(const S: ; Quote: Char):; Bir dizeden alıntılar
7	function AnsiStrComp(S1: PChar;S2: PChar):Integer; Dizeleri büyük / küçük harfe duyarlı olarak karşılaştırır
8	function AnsiStrIComp(S1: PChar; S2: PChar):Integer; Büyük / küçük harf duyarlı dizeleri karşılaştırır
9	function AnsiStrLComp(S1: PChar; S2: PChar; MaxLen: Cardinal):Integer; Büyük / küçük harfe duyarlı dizelerin L karakterlerini karşılaştırır
10	function AnsiStrLIComp(S1: PChar; S2: PChar; MaxLen: Cardinal):Integer; Büyük / küçük harf duyarlı dizelerin L karakterlerini karşılaştırır
11	function AnsiStrLastChar(Str: PChar):PChar; Dizenin son karakterini alır
12	function AnsiStrLower(Str: PChar):PChar; Dizeyi tamamen küçük harfe dönüştürür
13	function AnsiStrUpper(Str: PChar):PChar; Dizeyi tamamen büyük harfe dönüştürür
14	function AnsiUpperCase(const s:):; Dizeyi tamamen büyük harfe dönüştürür
15	procedure AppendStr(var Dest: ; const S:); 2 dize ekler
16	procedure AssignStr(var P: PString; const S:); Yığın üzerine dizelerin değerini atar
17	function CompareStr(const S1: ; const S2:):Integer; overload; İki dizeyi büyük / küçük harfe duyarlı olarak karşılaştırır
18	function CompareText(const S1: ; const S2:):Integer; Büyük / küçük harfe duyarlı olmayan iki dizeyi karşılaştırır
19	procedure DisposeStr(S: PString); overload; Dizeyi yığından kaldırır
20	procedure DisposeStr(S: PShortString); overload; Dizeyi yığından kaldırır
21	function IsValidIdent( const Ident:):Boolean; Dize geçerli bir pascal tanımlayıcı mı
22	function LastDelimiter(const Delimiters: ; const S:):Integer; Bir dizede karakterin son oluşumu
23	function LeftStr(const S: ; Count: Integer):; Bir dizenin ilk N karakterini alır
24	function LoadStr(Ident: Integer):; Kaynaklardan dizeyi yükler
25	function LowerCase(const s: ):; overload; Dizeyi tamamen küçük harfe dönüştürür
26	function LowerCase(const V: variant ):; overload; Dizeyi tamamen küçük harfe dönüştürür
27	function NewStr(const S:):PString; overload; Yığın üzerine yeni dizge ayırır
28	function RightStr(const S: ; Count: Integer):; Bir dizenin son N karakterini alır
29	function StrAlloc(Size: Cardinal):PChar; Dize için bellek ayırır
30	function StrBufSize(Str: PChar):SizeUInt; Bir dizge için bellek ayırır
31	procedure StrDispose(Str: PChar); Dizeyi yığından kaldırır
32	function StrPas(Str: PChar):; PChar'ı pascal dizeye dönüştürür
33	function StrPCopy(Dest: PChar; Source:):PChar; Pascal dizesini kopyalar
34	function StrPLCopy(Dest: PChar; Source: ; MaxLen: SizeUInt):PChar; Pascal dizesinin N baytını kopyalar
35	function UpperCase(const s:):; Dizeyi tamamen büyük harfe dönüştürür

Pascal, programcıların sabitler, değişkenler, işlevler ve ifadeler gibi mantıksal varlıkları tanımlamasına, depolamasına ve değiştirmesine olanak tanıyan veri türü Boolean sağlar.

Boole değerleri temelde tamsayı türüdür. Boole türü değişkenlerin önceden tanımlanmış iki olası değeri vardırTrue ve False. Bir Boolean değerine çözümlenen ifadeler ayrıca bir Boolean türüne atanabilir.

Free Pascal ayrıca ByteBool, WordBool ve LongBooltürleri. Bunlar sırasıyla Byte, Word veya Longint türleridir.

False değeri, 0 (sıfır) ile eşdeğerdir ve sıfır olmayan herhangi bir değer, bir Boole değerine dönüştürülürken True olarak kabul edilir. True'nun bir Boole değeri, LongBool türünde bir değişkene atanması durumunda -1'e dönüştürülür.

Mantıksal operatörlerin and, or ve not Boolean veri türleri için tanımlanmıştır.

Boolean Veri Türlerinin Bildirimi

Boolean türünde bir değişken, var anahtar sözcüğü kullanılarak bildirilir.

var
boolean-identifier: boolean;

Örneğin,

var
choice: boolean;

Misal

program exBoolean;
var
exit: boolean;

choice: char;
   begin
   writeln('Do you want to continue? ');
   writeln('Enter Y/y for yes, and N/n for no');
   readln(choice);

if(choice = 'n') then
   exit := true
else
   exit := false;

if (exit) then
   writeln(' Good Bye!')
else
   writeln('Please Continue');

readln;
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Do you want to continue?
Enter Y/y for yes, and N/n for no
N
Good Bye!
Y
Please Continue

Pascal programlama dili, dizi adı verilen ve aynı türden öğelerin sabit boyutlu sıralı bir koleksiyonunu depolayabilen bir veri yapısı sağlar. Bir dizi, bir veri koleksiyonunu depolamak için kullanılır, ancak bir diziyi aynı türden bir değişkenler koleksiyonu olarak düşünmek genellikle daha kullanışlıdır.

Sayı1, sayı2, ... ve sayı100 gibi tek tek değişkenleri bildirmek yerine, sayılar gibi bir dizi değişkeni bildirir ve temsil etmek için sayılar [1], sayılar [2] ve ..., sayılar [100] kullanırsınız bireysel değişkenler. Bir dizideki belirli bir öğeye bir dizinle erişilir.

Tüm diziler bitişik bellek konumlarından oluşur. En düşük adres ilk öğeye ve en yüksek adres son öğeye karşılık gelir.

Dizin 0'dan başlayan bir C stili dizisi istiyorsanız, dizini 1 yerine 0'dan başlatmanız gerektiğini lütfen unutmayın.

Dizileri Bildirme

Pascal'da bir dizi bildirmek için, bir programcı ya türü bildirebilir ve sonra bu dizinin değişkenlerini yaratabilir ya da doğrudan dizi değişkenini bildirebilir.

Tek boyutlu dizinin tür bildiriminin genel biçimi -

type
   array-identifier = array[index-type] of element-type;

Nerede,

• array-identifier - dizi türünün adını belirtir.

• index-type- dizinin alt simgesini belirtir; gerçek dışında herhangi bir skaler veri türü olabilir

• element-type - depolanacak değer türlerini belirtir

Örneğin,

type
   vector = array [ 1..25] of real;
var
   velocity: vector;

Şimdi, hız, 25'e kadar gerçek sayıyı tutmak için yeterli olan değişken bir vektör tipi dizisidir.

Diziyi 0 dizininden başlatmak için, bildirim -

type
   vector = array [ 0..24] of real;
var
   velocity: vector;

Dizi Alt Simge Türleri

Pascal'da, bir dizi alt simge, gerçek dışında tamsayı, Boole, numaralandırılmış veya alt aralık gibi herhangi bir skaler tipte olabilir. Dizi alt simgelerinin de negatif değerleri olabilir.

Örneğin,

type
   temperature = array [-10 .. 50] of real;
var
   day_temp, night_temp: temperature;

Alt simgenin karakter türünde olduğu başka bir örneği ele alalım -

type
   ch_array = array[char] of 1..26;
var
   alphabet: ch_array;

Alt simge, numaralandırılmış türde olabilir -

type
   color = ( red, black, blue, silver, beige);
   car_color = array of [color] of boolean;
var
   car_body: car_color;

Dizileri Başlatma

Pascal'da diziler, belirli bir alt simge belirtilerek veya bir for-do döngüsü kullanılarak atama yoluyla başlatılır.

Örneğin -

type
   ch_array = array[char] of 1..26;
var
   alphabet: ch_array;
   c: char;

begin
   ...
   for c:= 'A' to 'Z' do
   alphabet[c] := ord[m];  
   (* the ord() function returns the ordinal values *)

Dizi Öğelerine Erişim

Dizi adını indeksleyerek bir elemana erişilir. Bu, elemanın dizini dizinin isminden sonra köşeli parantez içine yerleştirilerek yapılır. Örneğin -

a: integer;
a: = alphabet['A'];

Yukarıdaki ifade, alfabe adlı diziden ilk öğeyi alacak ve değeri a değişkenine atayacaktır.

Aşağıda, yukarıda bahsedilen üç kavramın tamamını kullanacak bir örnek verilmiştir. bildirim, atama ve dizilere erişim -

program exArrays;
var
   n: array [1..10] of integer;   (* n is an array of 10 integers *)
   i, j: integer;

begin
   (* initialize elements of array n to 0 *)        
   for i := 1 to 10 do
       n[ i ] := i + 100;   (* set element at location i to i + 100 *)
    (* output each array element's value *)
   
   for j:= 1 to 10 do
      writeln('Element[', j, '] = ', n[j] );
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
Element[10] = 110

Ayrıntılı Pascal Dizileri

Diziler Pascal için önemlidir ve çok daha fazla ayrıntıya ihtiyaç duymalıdır. Bir Pascal programcısı için açık olması gereken, dizi ile ilgili aşağıdaki birkaç önemli kavram vardır:

Sr.No	Konsept ve Açıklama
1	Çok boyutlu diziler Pascal, çok boyutlu dizileri destekler. Çok boyutlu dizinin en basit şekli iki boyutlu dizidir.
2	Dinamik dizi Bu tür dizilerde başlangıç ​​uzunluğu sıfırdır. Dizinin gerçek uzunluğu standart olarak ayarlanmalıdırSetLength işlevi.
3	Paketlenmiş dizi Bu diziler bit paketlidir, yani her karakter veya doğruluk değerleri, genellikle bir kelime (4 bayt veya daha fazla) olmak üzere bir depolama birimi kullanmak yerine ardışık baytlarda saklanır.
4	Dizileri alt programlara geçirme Dizinin adını indeks olmadan belirterek, bir alt programa bir diziye bir işaretçi aktarabilirsiniz.

Pascal'daki işaretçileri öğrenmesi kolay ve eğlencelidir. Bazı Pascal programlama görevleri işaretçilerle daha kolay gerçekleştirilir ve dinamik bellek ayırma gibi diğer görevler işaretçiler kullanılmadan gerçekleştirilemez. Bu yüzden mükemmel bir Pascal programcısı olmak için işaretçileri öğrenmek gerekli hale geliyor. Bunları basit ve kolay adımlarla öğrenmeye başlayalım.

Bildiğiniz gibi, her değişken bir bellek konumudur ve her bellek konumu, bellekteki bir adresi belirten işaretçi değişkeninin adı kullanılarak erişilebilen tanımlanmış bir adresine sahiptir.

İşaretçiler Nelerdir?

Bir işaretçi, değeri başka bir değişkenin adresi, yani bellek konumunun doğrudan adresi olan dinamik bir değişkendir. Herhangi bir değişken veya sabit gibi, herhangi bir değişken adresini saklamak için kullanmadan önce bir işaretçi bildirmelisiniz. Bir işaretçi değişken bildiriminin genel şekli -

type
   ptr-identifier = ^base-variable-type;

İşaretçi türü, düzeltme sembolünün (^) yukarı okunun önüne temel tür eklenerek tanımlanır. Temel tür, veri öğelerinin türlerini tanımlar. Bir işaretçi değişkeni belirli türde olacak şekilde tanımlandığında, yalnızca o türdeki veri öğelerini işaret edebilir. Bir işaretçi türü tanımlandıktan sonra,var işaretçi değişkenlerini bildirmek için bildirim.

var
   p1, p2, ... : ptr-identifier;

Aşağıda bazı geçerli işaretçi bildirimleri verilmiştir -

type
   Rptr = ^real;
   Cptr = ^char;
   Bptr = ^ Boolean;
   Aptr = ^array[1..5] of real;
   date-ptr = ^ date;
      Date = record
         Day: 1..31;
         Month: 1..12;
         Year: 1900..3000;
      End;
var
   a, b : Rptr;
   d: date-ptr;

İşaretçi değişkenlerinin referansı aynı düzeltme simgesi (^) kullanılarak kaldırılır. Örneğin, ilişkili değişken bir işaretçi tarafından sevk BioLRptr olduğu ^ BioLRptr . Şu şekilde erişilebilir -

rptr^ := 234.56;

Aşağıdaki örnek bu kavramı açıklayacaktır -

program exPointers;
var
   number: integer;
   iptr: ^integer;

begin
   number := 100;
   writeln('Number is: ', number);
   
   iptr := @number;
   writeln('iptr points to a value: ', iptr^);
   
   iptr^ := 200;
   writeln('Number is: ', number);
   writeln('iptr points to a value: ', iptr^);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Number is: 100
iptr points to a value: 100
Number is: 200
iptr points to a value: 200

Pascal'da Bellek Adresi Yazdırma

Pascal'da, adres operatörünü (@) kullanarak bir değişkenin adresini bir işaretçi değişkenine atayabiliriz. Bu işaretçiyi veri öğesini işlemek ve ona erişmek için kullanıyoruz. Ancak, herhangi bir nedenle bellek adresinin kendisiyle çalışmamız gerekirse, onu bir sözcük türü değişkeninde saklamamız gerekir.

İptr işaretçisinde depolanan bellek adresini yazdırmak için yukarıdaki örneği genişletelim -

program exPointers;
var
   number: integer;
   iptr: ^integer;
   y: ^word;

begin
   number := 100;
   writeln('Number is: ', number);
   iptr := @number;
   writeln('iptr points to a value: ', iptr^);
   
   iptr^ := 200;
   writeln('Number is: ', number);
   writeln('iptr points to a value: ', iptr^);
   y := addr(iptr);
   writeln(y^); 
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Number is: 100
iptr points to a value: 100
Number is: 200
iptr points to a value: 200
45504

NIL İşaretçiler

Bir atamak her zaman iyi bir uygulamadır. NILatanacak tam adresinizin olmaması durumunda bir işaretçi değişkenine değer. Bu, değişken bildirimi sırasında yapılır. Atanan bir işaretçiNILhiçbir yere işaret etmiyor. Aşağıdaki programı düşünün -

program exPointers;
var
   number: integer;
   iptr: ^integer;
   y: ^word;

begin
   iptr := nil;
   y := addr(iptr);
   
   writeln('the vaule of iptr is ', y^);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

The value of ptr is 0

Kontrol etmek için nil işaretçi aşağıdaki gibi bir if ifadesini kullanabilirsiniz -

if(ptr <> nill )then     (* succeeds if p is not null *)
if(ptr = nill)then    (* succeeds if p is null *)

Ayrıntılı Pascal İşaretçileri

İşaretçilerin birçok ama kolay kavramları vardır ve Pascal programlaması için çok önemlidirler. Bir Pascal programcısı için açık olması gereken birkaç önemli işaretçi kavramı vardır:

Sr.No	Konsept ve Açıklama
1	Pascal - İşaretçi aritmetiği İşaretçilerde kullanılabilecek dört aritmetik operatör vardır: artırma, azaltma, +, -
2	Pascal - İşaretçiler dizisi Bir dizi işaretçi tutacak diziler tanımlayabilirsiniz.
3	Pascal - Pointer to pointer Pascal allows you to have pointer on a pointer and so on.
4	Passing pointers to subprograms in Pascal Passing an argument by reference or by address both enable the passed argument to be changed in the calling subprogram by the called subprogram.
5	Return pointer from subprograms in Pascal Pascal allows a subprogram to return a pointer.

Pascal arrays allow you to define type of variables that can hold several data items of the same kind but a record is another user-defined data type available in Pascal which allows you to combine data items of different kinds.

Records consist of different fields. Suppose you want to keep track of your books in a library, you might want to track the following attributes about each book −

• Title
• Author
• Subject
• Book ID

Defining a Record

To define a record type, you may use the type declaration statement. The record type is defined as −

type
record-name = record
   field-1: field-type1;
   field-2: field-type2;
   ...
   field-n: field-typen;
end;

Here is the way you would declare the Book record −

type 
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: integer;
end;

The record variables are defined in the usual way as

var
   r1, r2, ... : record-name;

Alternatively, you can directly define a record type variable as −

var
Books : record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: integer;
end;

Accessing Fields of a Record

To access any field of a record, we use the member access operator (.). The member access operator is coded as a period between the record variable name and the field that we wish to access. Following is the example to explain usage of structure −

program exRecords;
type
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
   Book1, Book2: Books; (* Declare Book1 and Book2 of type Books *)

begin
   (* book 1 specification *)
   Book1.title  := 'C Programming';
   Book1.author := 'Nuha Ali '; 
   Book1.subject := 'C Programming Tutorial';
   Book1.book_id := 6495407;

   (* book 2 specification *)
   Book2.title := 'Telecom Billing';
   Book2.author := 'Zara Ali';
   Book2.subject := 'Telecom Billing Tutorial';
   Book2.book_id := 6495700;
 
   (* print Book1 info *)
   writeln ('Book 1 title : ', Book1.title);
   writeln('Book 1 author : ', Book1.author);
   writeln( 'Book 1 subject : ', Book1.subject);
   writeln( 'Book 1 book_id : ', Book1.book_id);
   writeln; 

   (* print Book2 info *)
   writeln ('Book 2 title : ', Book2.title);
   writeln('Book 2 author : ', Book2.author);
   writeln( 'Book 2 subject : ', Book2.subject);
   writeln( 'Book 2 book_id : ', Book2.book_id);
end.

When the above code is compiled and executed, it produces the following result −

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Records as Subprogram Arguments

You can pass a record as a subprogram argument in very similar way as you pass any other variable or pointer. You would access the record fields in the similar way as you have accessed in the above example −

program exRecords;
type
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
   Book1, Book2: Books; (* Declare Book1 and Book2 of type Books *)

(* procedure declaration *)
procedure printBook( var book: Books );

begin
   (* print Book info *)
   writeln ('Book  title : ', book.title);
   writeln('Book  author : ', book.author);
   writeln( 'Book  subject : ', book.subject);
   writeln( 'Book book_id : ', book.book_id);
end;

begin
   (* book 1 specification *)
   Book1.title  := 'C Programming';
   Book1.author := 'Nuha Ali '; 
   Book1.subject := 'C Programming Tutorial';
   Book1.book_id := 6495407;
   
   (* book 2 specification *)
   Book2.title := 'Telecom Billing';
   Book2.author := 'Zara Ali';
   Book2.subject := 'Telecom Billing Tutorial';
   Book2.book_id := 6495700;
   
   (* print Book1 info *)
   printbook(Book1);
   writeln; 

   (* print Book2 info *)
   printbook(Book2);
end.

When the above code is compiled and executed, it produces the following result −

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Pointers to Records

You can define pointers to records in very similar way as you define pointer to any other variable as follows −

type
record-ptr = ^ record-name;
record-name = record
   field-1: field-type1;
   field-2: field-type2;
   ...
   field-n: field-typen;
end;

Now, you can store the address of a record type variable in the above-defined pointer variable. To declare a variable of the created pointer type, you use the var keyword −

var
   r1, r2, ... : record-ptr;

Before using these pointers, you must create storage for a record-name type variable, which will be manipulated by these pointers.

new(r1);
new(r2);

To access the members of a record using a pointer to that record, you must use the ^. operator as follows −

r1^.feild1 := value1;
r1^.feild2 := value2;
...
r1^fieldn := valuen;

Finally, don't forget to dispose the used storage, when it is no longer in use −

dispose(r1);
dispose(r2);

Let us re-write the first example using a pointer to the Books record. Hope this will be easy for you to understand the concept −

program exRecords;
type
BooksPtr = ^ Books;
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
  (* Declare Book1 and Book2 of pointer type that refers to Book type *)
   Book1, Book2: BooksPtr; 

begin
   new(Book1);
   new(book2);
   
   (* book 1 specification *)
   Book1^.title  := 'C Programming';
   Book1^.author := 'Nuha Ali '; 
   Book1^.subject := 'C Programming Tutorial';
   Book1^.book_id := 6495407;
   
   (* book 2 specification *)
   Book2^.title := 'Telecom Billing';
   Book2^.author := 'Zara Ali';
   Book2^.subject := 'Telecom Billing Tutorial';
   Book2^.book_id := 6495700;
   
   (* print Book1 info *)
   writeln ('Book 1 title : ', Book1^.title);
   writeln('Book 1 author : ', Book1^.author);
   writeln( 'Book 1 subject : ', Book1^.subject);
   writeln( 'Book 1 book_id : ', Book1^.book_id);
   
   (* print Book2 info *)
   writeln ('Book 2 title : ', Book2^.title);
   writeln('Book 2 author : ', Book2^.author);
   writeln( 'Book 2 subject : ', Book2^.subject);
   writeln( 'Book 2 book_id : ', Book2^.book_id);
   
   dispose(Book1); 
   dispose(Book2);
end.

When the above code is compiled and executed, it produces the following result −

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

The With Statement

We have discussed that the members of a record can be accessed using the member access operator (.). This way the name of the record variable has to be written every time. The With statement provides an alternative way to do that.

Look at the following code snippet taken from our first example −

(* book 1 specification *)
   Book1.title  := 'C Programming';
   Book1.author := 'Nuha Ali '; 
   Book1.subject := 'C Programming Tutorial';
   Book1.book_id := 6495407;

The same assignment could be written using the With statement as −

(* book 1 specification *)
With Book1 do
begin
   title  := 'C Programming';
   author := 'Nuha Ali '; 
   subject := 'C Programming Tutorial';
   book_id := 6495407;
end;

Pascal supports a unique type of storage named variants. You can assign any simple type of values in a variant variable. The type of a value stored in a variant is only determined at runtime. Almost any simple type can be assigned to variants: ordinal types, string types, int64 types.

Structured types such as sets, records, arrays, files, objects and classes are not assignment-compatible with a variant. You can also assign a pointer to a variant.

Free Pascal supports variants.

Declaring a Variant

You can declare variant type like any other types using the var keyword. The syntax for declaring a variant type is −

var
   v: variant;

Now, this variant variable v can be assigned to almost all simple types including the enumerated types and vice versa.

type  
   color = (red, black, white);  
var  
   v : variant;  
   i : integer;  
   b : byte;  
   w : word;  
   q : int64;  
   e : extended;  
   d : double;  
   en : color;  
   as : ansistring;  
   ws : widestring;  

begin  
   v := i;  
   v := b;  
   v := w;  
   v := q;  
   v := e;  
   v := en;  
   v := d:  
   v := as;  
   v := ws;  
end;

Example

The following example would illustrate the concept −

Program exVariant;

uses variants;
type
   color = (red, black, white);

var
   v : variant;
   i : integer;
   r: real;
   c : color;
   as : ansistring;


begin
   i := 100;
   v:= i;
   writeln('Variant as Integer: ', v);

   r:= 234.345;
   v:= r;
   writeln('Variant as real: ', v);

   c := red;
   v := c;
   writeln('Variant as Enumerated data: ', v);

   as:= ' I am an AnsiString';
   v:= as;
   writeln('Variant as AnsiString: ', v);
end.

When the above code is compiled and executed, it produces the following result −

Variant as Integer: 100
Variant as real: 234.345
Variant as Enumerated data: 0
Variant as AnsiString: I am an AnsiString

A set is a collection of elements of same type. Pascal allows defining the set data type. The elements in a set are called its members. In mathematics, sets are represented by enclosing the members within braces{}. However, in Pascal, set elements are enclosed within square brackets [], which are referred as set constructor.

Defining Set Types and Variables

Pascal Set types are defined as

type
set-identifier = set of base type;

Variables of set type are defined as

var
s1, s2, ...: set-identifier;

or,

s1, s2...: set of base type;

Examples of some valid set type declaration are −

type
Days = (mon, tue, wed, thu, fri, sat, sun);
Letters = set of char;
DaySet = set of days;
Alphabets = set of 'A' .. 'Z';
studentAge = set of 13..20;

Set Operators

You can perform the following set operations on Pascal sets.

Sr.No	Operations & Descriptions
1	Union This joins two sets and gives a new set with members from both sets.
2	Difference Gets the difference of two sets and gives a new set with elements not common to either set.
3	Intersection Gets the intersection of two sets and gives a new set with elements common to both sets.
4	Inclusion A set P is included in set Q, if all items in P are also in Q but not vice versa.
5	Symmetric difference Gets the symmetric difference of two sets and gives a set of elements, which are in either of the sets and not in their intersection.
6	In It checks membership.

Following table shows all the set operators supported by Free Pascal. Assume that S1 and S2 are two character sets, such that −

S1 := ['a', 'b', 'c'];

S2 := ['c', 'd', 'e'];

Operator	Description	Example
+	Union of two sets	S1 + S2 will give a set ['a', 'b', 'c', 'd', 'e']
-	Difference of two sets	S1 - S2 will give a set ['a', 'b']
*	Intersection of two sets	S1 * S2 will give a set ['c']
><	Symmetric difference of two sets	S1 >< S2 will give a set ['a', 'b', 'd', 'e']
=	Checks equality of two sets	S1 = S2 will give the boolean value False
<>	Checks non-equality of two sets	S1 <> S2 will give the boolean value True
<=	Contains (Checks if one set is a subset of the other)	S1 <= S2 will give the boolean value False
Include	Includes an element in the set; basically it is the Union of a set and an element of same base type	Include (S1, ['d']) will give a set ['a', 'b', 'c', 'd']
Exclude	Excludes an element from a set; basically it is the Difference of a set and an element of same base type	Exclude (S2, ['d']) will give a set ['c', 'e']
In	Checks set membership of an element in a set	['e'] in S2 gives the boolean value True

Example

The following example illustrates the use of some of these operators −

program setColors;
type  
color = (red, blue, yellow, green, white, black, orange);  
colors = set of color;  
 
procedure displayColors(c : colors);  
const  
names : array [color] of String[7]  
  = ('red', 'blue', 'yellow', 'green', 'white', 'black', 'orange');  
var  
   cl : color;  
   s : String;  

begin  
   s:= ' ';  
   for cl:=red to orange do  
      if cl in c then  
      begin  
         if (s<>' ') then s :=s +' , ';  
         s:=s+names[cl];  
      end;  
   writeln('[',s,']');  
end;  
 
var  
   c : colors;  
 
begin  
   c:= [red, blue, yellow, green, white, black, orange];
   displayColors(c);

   c:=[red, blue]+[yellow, green]; 
   displayColors(c);  

   c:=[red, blue, yellow, green, white, black, orange] - [green, white];     
   displayColors(c);    

   c:= [red, blue, yellow, green, white, black, orange]*[green, white];     
   displayColors(c);  

   c:= [red, blue, yellow, green]><[yellow, green, white, black]; 
   displayColors(c);  
end.

When the above code is compiled and executed, it produces the following result −

[ red , blue , yellow , green , white , black , orange]
[ red , blue , yellow , green]
[ red , blue , yellow , black , orange]
[ green , white]
[ red , blue , white , black]

Pascal treats a file as a sequence of components, which must be of uniform type. A file's type is determined by the type of the components. File data type is defined as −

type
file-name = file of base-type;

Where, the base-type indicates the type of the components of the file. The base type could be anything like, integer, real, Boolean, enumerated, subrange, record, arrays and sets except another file type. Variables of a file type are created using the var declaration −

var
f1, f2,...: file-name;

Aşağıda, bazı dosya türlerini ve dosya değişkenlerini tanımlamaya ilişkin bazı örnekler verilmiştir -

type
   rfile = file of real;
   ifile = file of integer;
   bfile = file of boolean;
   datafile = file of record
   arrfile = file of array[1..4] of integer;

var
   marks: arrfile;
   studentdata: datafile;
   rainfalldata: rfile;
   tempdata: ifile;
   choices: bfile;

Dosya Oluşturma ve Dosyaya Yazma

Öğrencilerin kayıtları için bir veri dosyası oluşturacak bir program yazalım. Students.dat adında bir dosya oluşturur ve bir öğrencinin verilerini içine yazar -

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   Assign(f,'students.dat');
   Rewrite(f);
   Student.s_name := 'John Smith';
   Student.s_addr := 'United States of America';
   Student.s_batchcode := 'Computer Science';
   Write(f,Student);
   Close(f);
end.

Derlendiğinde ve çalıştırıldığında, program çalışma dizinine öğrenciler.dat adında bir dosya oluşturur . Dosyayı, John Smith'in verilerine bakmak için not defteri gibi bir metin düzenleyicisi kullanarak açabilirsiniz.

Dosyadan Okuma

Öğrenciler.dat adlı bir dosyaya yeni oluşturduk ve yazdık. Şimdi, öğrencinin verilerini dosyadan okuyacak bir program yazalım -

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   assign(f, 'students.dat');
   reset(f); 
   while not eof(f) do
   
   begin
      read(f,Student);
      writeln('Name: ',Student.s_name);
      writeln('Address: ',Student.s_addr);
      writeln('Batch Code: ', Student.s_batchcode);
   end;
   
   close(f);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Name: John Smith
Address: United States of America
Batch Code: Computer Science

Alt Program Parametresi Olarak Dosyalar

Pascal, dosya değişkenlerinin standart ve kullanıcı tanımlı alt programlarda parametre olarak kullanılmasına izin verir. Aşağıdaki örnek bu kavramı göstermektedir. Program, rainfall.txt adlı bir dosya oluşturur ve bazı yağış verilerini depolar. Ardından dosyayı açar, verileri okur ve ortalama yağış miktarını hesaplar.

Lütfen bunu not al, if you use a file parameter with subprograms, it must be declared as a var parameter.

program addFiledata;
const
   MAX = 4;
type
   raindata = file of real;

var
   rainfile: raindata;
   filename: string;
procedure writedata(var f: raindata);

var
   data: real;
   i: integer;

begin
   rewrite(f, sizeof(data));
   for i:=1 to MAX do
   
   begin
      writeln('Enter rainfall data: ');
      readln(data);
      write(f, data);
   end;
   
   close(f);
end;

procedure computeAverage(var x: raindata);
var
   d, sum: real;
   average: real;

begin
   reset(x);
   sum:= 0.0;
   while not eof(x) do
   
   begin
      read(x, d);
      sum := sum + d;
   end;
   
   average := sum/MAX;
   close(x);
   writeln('Average Rainfall: ', average:7:2);
end;

begin
   writeln('Enter the File Name: ');
   readln(filename);
   assign(rainfile, filename);
   writedata(rainfile);
   computeAverage(rainfile);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter the File Name:
rainfall.txt
Enter rainfall data:
34
Enter rainfall data:
45
Enter rainfall data:
56
Enter rainfall data:
78
Average Rainfall: 53.25

Metin Dosyaları

Pascal'daki bir metin dosyası, her satırın bir satır sonu işaretçisi ile sonlandırıldığı karakter satırlarından oluşur. Bu tür dosyaları şu şekilde bildirebilir ve tanımlayabilirsiniz:

type
file-name = text;

Normal bir karakter dosyası ile bir metin dosyası arasındaki fark, bir metin dosyasının satırlara bölünmesidir, her biri özel bir satır sonu işaretçisi ile sonlandırılır ve sistem tarafından otomatik olarak eklenir. Aşağıdaki örnek, contact.txt adlı bir metin dosyası oluşturur ve ona yazar -

program exText;
var
   filename, data: string;
   myfile: text;

begin
   writeln('Enter the file name: ');
   readln(filename);
   
   assign(myfile, filename);
   rewrite(myfile);
   
   writeln(myfile, 'Note to Students: ');
   writeln(myfile, 'For details information on Pascal Programming');
   writeln(myfile, 'Contact: Tutorials Point');
   writeln('Completed writing'); 
   
   close(myfile);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter the file name:
contact.txt 
Completed writing

Dosyaya Ekleme

Bir dosyaya eklemek, zaten bazı verileri içeren mevcut bir dosyaya dosyanın üzerine yazmadan yazmak anlamına gelir. Aşağıdaki program bunu göstermektedir -

program exAppendfile;
var
   myfile: text;
   info: string;

begin
   assign(myfile, 'contact.txt');
   append(myfile);
   
   writeln('Contact Details');
   writeln('[email protected]');
   close(myfile);
   
   (* let us read from this file *)
   assign(myfile, 'contact.txt');
   reset(myfile);
   while not eof(myfile) do
   
   begin
      readln(myfile, info);
      writeln(info);
   end;
   close(myfile);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Contact Details
[email protected]
Note to Students:
For details information on Pascal Programming
Contact: Tutorials Point

Dosya İşleme İşlevleri

Free Pascal, dosya işleme için aşağıdaki işlevleri / prosedürleri sağlar -

Sr.No.	Fonksiyon Adı ve Tanımı
1	procedure Append(var t: Text); Ekleme modunda bir dosya açar
2	procedure Assign(out f: file; const Name:); Bir dosyaya bir isim atar
3	procedure Assign(out f: file; p: PChar); Bir dosyaya bir isim atar
4	procedure Assign(out f: file; c: Char); Bir dosyaya bir isim atar
5	procedure Assign(out f: TypedFile; const Name:); Bir dosyaya bir isim atar
6	procedure Assign(out f: TypedFile; p: PChar); Bir dosyaya bir isim atar
7	procedure Assign(out f: TypedFile; c: Char); Bir dosyaya bir isim atar
8	procedure Assign(out t: Text; const s:); Bir dosyaya bir isim atar
9	procedure Assign(out t: Text; p: PChar); Bir dosyaya bir isim atar
10	procedure Assign(out t: Text; c: Char); Bir dosyaya bir isim atar
11	procedure BlockRead(var f: file; var Buf; count: Int64; var Result: Int64); Bir dosyadaki verileri belleğe okur
12	procedure BlockRead(var f: file; var Buf; count: LongInt; var Result: LongInt); Bir dosyadaki verileri belleğe okur
13	procedure BlockRead(var f: file; var Buf; count: Cardinal; var Result: Cardinal); Bir dosyadaki verileri belleğe okur
14	procedure BlockRead(var f: file; var Buf; count: Word; var Result: Word); Bir dosyadaki verileri belleğe okur
15	procedure BlockRead(var f: file; var Buf; count: Word; var Result: Integer); Bir dosyadaki verileri belleğe okur
16	procedure BlockRead(var f: file; var Buf; count: Int64); Bir dosyadaki verileri belleğe okur
17	procedure BlockWrite(var f: file; const Buf; Count: Int64; var Result: Int64); Verileri bellekten bir dosyaya yazar
18	procedure BlockWrite(var f: file; const Buf; Count: LongInt; var Result: LongInt); Verileri bellekten bir dosyaya yazar
19	procedure BlockWrite(var f: file; const Buf; Count: Cardinal; var Result: Cardinal); Verileri bellekten bir dosyaya yazar
20	procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Word); Verileri bellekten bir dosyaya yazar
21	procedure BlockWrite(var f: file; const Buf; Count: Word; var Result: Integer); Verileri bellekten bir dosyaya yazar
22	procedure BlockWrite(var f: file; const Buf; Count: LongInt); Verileri bellekten bir dosyaya yazar
23	procedure Close(var f: file); Bir dosyayı kapatır
24	procedure Close(var t: Text); Bir dosyayı kapatır
25	function EOF(var f: file):Boolean; Dosyanın sonunu kontrol eder
26	function EOF(var t: Text):Boolean; Dosyanın sonunu kontrol eder
27	function EOF: Boolean; Dosyanın sonunu kontrol eder
28	function EOLn(var t: Text):Boolean; Hat sonu kontrolleri
29	function EOLn: Boolean; Hat sonu kontrolleri
30	procedure Erase(var f: file); Dosyayı diskten siler
31	procedure Erase(var t: Text); Dosyayı diskten siler
32	function FilePos( var f: file):Int64; Dosyadaki pozisyon
33	function FileSize(var f: file):Int64; Dosya boyutu
34	procedure Flush(var t: Text); Dosya arabelleklerini diske yazar
35	function IOResult: Word; Son dosya GÇ işleminin sonucunu verir
36	procedure Read(var F: Text; Args: Arguments); Dosyadan değişkene okur
37	procedure Read(Args: Arguments); Dosyadan değişkene okur
38	procedure ReadLn(var F: Text; Args: Arguments); Dosyadan değişkene okur ve sonraki satıra gider
39	procedure ReadLn(Args: Arguments); Dosyadan değişkene okur ve sonraki satıra gider
40	procedure Rename(var f: file; const s:); Diskteki dosyayı yeniden adlandırır
41	procedure Rename(var f: file; p: PChar); Diskteki dosyayı yeniden adlandırır
42	procedure Rename(var f: file; c: Char); Diskteki dosyayı yeniden adlandırır
43	procedure Rename(var t: Text; const s); Diskteki dosyayı yeniden adlandırın
44	procedure Rename(var t: Text; p: PChar); Diskteki dosyayı yeniden adlandırır
45	procedure Rename( var t: Text; c: Char); Diskteki dosyayı yeniden adlandırır
46	procedure Reset(var f: file; l: LongInt); Dosyayı okumak için açar
47	procedure Reset(var f: file); Dosyayı okumak için açar
48	procedure Reset(var f: TypedFile); Dosyayı okumak için açar
49	procedure Reset(var t: Text); Dosyayı okumak için açar
50	procedure Rewrite(var f: file; l: LongInt); Dosyayı yazmak için açar
51	procedure Rewrite(var f: file); Dosyayı yazmak için açar
52	procedure Rewrite(var f: TypedFile); Dosyayı yazmak için açar
53	procedure Rewrite(var t: Text); Dosyayı yazmak için açar
54	procedure Seek(var f: file; Pos: Int64); Dosya konumunu ayarlar
55	function SeekEOF(var t: Text):Boolean; Dosya konumunu dosyanın sonuna ayarlar
56	function SeekEOF: Boolean; Dosya konumunu dosyanın sonuna ayarlar
57	function SeekEOLn(var t: Text):Boolean; Dosya konumunu satırın sonuna ayarlar
58	function SeekEOLn: Boolean; Dosya konumunu satırın sonuna ayarlar
59	procedure SetTextBuf(var f: Text; var Buf); Dosya arabelleğinin boyutunu belirler
60	procedure SetTextBuf(var f: Text; var Buf; Size: SizeInt); Dosya arabelleğinin boyutunu belirler
61	procedure Truncate(var F: file); Dosyayı konumunda kesin
62	procedure Write(Args: Arguments); Değişkeni dosyaya yazar
63	procedure Write(var F: Text; Args: Arguments); Değişkeni dosyaya yaz
64	procedure Writeln(Args: Arguments); Değişkeni dosyaya yazar ve satırsonu ekler
65	procedure WriteLn(var F: Text; Args: Arguments); Değişkeni dosyaya yazar ve satırsonu ekler

Bu bölüm, Pascal'da dinamik bellek yönetimini açıklamaktadır. Pascal programlama dili, bellek tahsisi ve yönetimi için çeşitli işlevler sağlar.

Belleği Dinamik Olarak Ayırma

Programlama yaparken, bir dizinin boyutunun farkındaysanız, o zaman kolaydır ve onu bir dizi olarak tanımlayabilirsiniz. Örneğin, herhangi bir kişinin adını saklamak için, en fazla 100 karakter gidebilir, böylece bir şeyi aşağıdaki gibi tanımlayabilirsiniz -

var
name: array[1..100] of char;

Ama şimdi, saklamanız gereken metnin uzunluğu hakkında hiçbir fikrinizin olmadığı, örneğin bir konu hakkında ayrıntılı bir açıklama saklamak istediğiniz bir durumu ele alalım. Burada, ne kadar bellek gerektiğini tanımlamadan dizgeye bir işaretçi tanımlamamız gerekiyor.

Pascal bir prosedür sağlar newişaretçi değişkenleri oluşturmak için.

program exMemory;
var
name: array[1..100] of char;
description: ^string;

begin
   name:= 'Zara Ali';
   
   new(description);
      if not assigned(description) then
         writeln(' Error - unable to allocate required memory')
      else
         description^ := 'Zara ali a DPS student in class 10th';
   writeln('Name = ', name );
   writeln('Description: ', description^ );
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Name = Zara Ali
Description: Zara ali a DPS student in class 10th

Şimdi, daha sonra başvurulacak belirli sayıda bayt içeren bir işaretçi tanımlamanız gerekirse, getmem function veya the getmem aşağıdaki sözdizimine sahip yordam -

procedure Getmem(
   out p: pointer;
   Size: PtrUInt
);

function GetMem(
   size: PtrUInt
):pointer;

Önceki örnekte, bir dizgeye bir işaretçi bildirdik. Bir dizenin maksimum değeri 255 bayttır. Bayt cinsinden gerçekten bu kadar alana veya daha büyük bir alana ihtiyacınız yoksa, getmem alt programı bunu belirlemenize izin verir. Getmem'i kullanarak önceki örneği yeniden yazalım -

program exMemory;
var
name: array[1..100] of char;
description: ^string;

begin
   name:= 'Zara Ali';
   
   description := getmem(200);
      if not assigned(description) then
         writeln(' Error - unable to allocate required memory')
      else
         description^ := 'Zara ali a DPS student in class 10th';
   writeln('Name = ', name );
   writeln('Description: ', description^ );
   
   freemem(description);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Name = Zara Ali
Description: Zara ali a DPS student in class 10th

Böylece, tam kontrole sahip olursunuz ve dizilerden farklı olarak belleği ayırırken herhangi bir boyut değerini geçebilirsiniz, burada boyutu bir kez tanımladıktan sonra değiştirilemez.

Belleği Yeniden Boyutlandırma ve Serbest Bırakma

Programınız çıktığında, işletim sistemi programınız tarafından ayrılan tüm belleği otomatik olarak serbest bırakır, ancak artık belleğe ihtiyacınız kalmadığında iyi bir uygulama olarak bu belleği serbest bırakmalısınız.

Pascal prosedürü sağlar dispose yordamı kullanarak dinamik olarak oluşturulmuş bir değişkeni serbest bırakmak new. Kullanarak bellek ayırdıysanız getmem alt program, ardından alt programı kullanmanız gerekir freemembu hafızayı boşaltmak için. Freemem altprogramların sözdizimi şöyle -

procedure Freemem(
   p: pointer;
  Size: PtrUInt
);

function Freemem(
   p: pointer
):PtrUInt;

Alternatif olarak, ReAllocMem işlevini çağırarak ayrılmış bir bellek bloğunun boyutunu artırabilir veya azaltabilirsiniz . Yukarıdaki programı bir kez daha kontrol edelim ve ReAllocMem ve freemem alt programlarını kullanalım . ReAllocMem için sözdizimi aşağıdadır -

function ReAllocMem(
   var p: pointer;
   Size: PtrUInt
):pointer;

Aşağıda, ReAllocMem ve freemem alt programlarını kullanan bir örnek verilmiştir -

program exMemory;
var
name: array[1..100] of char;
description: ^string;
desp: string;

begin
   name:= 'Zara Ali';
   desp := 'Zara ali a DPS student.';
   
   description := getmem(30);
      if not assigned(description) then
         writeln('Error - unable to allocate required memory')
      else
         description^ := desp;

   (* Suppose you want to store bigger description *)
   description := reallocmem(description, 100);
   desp := desp + ' She is in class 10th.';
   description^:= desp; 
   
   writeln('Name = ', name );
   writeln('Description: ', description^ );
   
   freemem(description);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Name = Zara Ali
Description: Zara ali a DPS student. She is in class 10th

Bellek Yönetimi İşlevleri

Pascal, çeşitli veri yapılarının uygulanmasında ve Pascal'da düşük seviyeli programlamanın uygulanmasında kullanılan bir yığın bellek yönetimi işlevi sağlar. Bu işlevlerin çoğu uygulamaya bağlıdır. Free Pascal, bellek yönetimi için aşağıdaki işlevleri ve prosedürleri sağlar -

SN	Fonksiyon Adı ve Tanımı
1	function Addr(X: TAnytype):Pointer; Değişkenin adresini verir
2	function Assigned(P: Pointer):Boolean; Bir işaretçinin geçerli olup olmadığını kontrol eder
3	function CompareByte(const buf1; const buf2; len: SizeInt):SizeInt; Bayt başına 2 bellek tampon baytını karşılaştırır
4	function CompareChar(const buf1; const buf2; len: SizeInt):SizeInt; Bayt başına 2 bellek tampon baytını karşılaştırır
5	function CompareDWord(const buf1; const buf2; len: SizeInt):SizeInt; Bayt başına 2 bellek tampon baytını karşılaştırır
6	function CompareWord(const buf1; const buf2; len: SizeInt):SizeInt; Bayt başına 2 bellek tampon baytını karşılaştırır
7	function Cseg: Word; Kod segmentini verir
8	procedure Dispose(P: Pointer); Dinamik olarak ayrılmış belleği serbest bırakır
9	procedure Dispose(P: TypedPointer; Des: TProcedure); Dinamik olarak ayrılmış belleği serbest bırakır
10	function Dseg: Word; Veri segmentini verir
11	procedure FillByte(var x; count: SizeInt; value: Byte); Bellek bölgesini 8 bit desenle doldurur
12	procedure FillChar( var x; count: SizeInt; Value: Byte|Boolean|Char); Hafıza bölgesini belirli karakterlerle doldurur
13	procedure FillDWord( var x; count: SizeInt; value: DWord); Bellek bölgesini 32 bit desenle doldurur
14	procedure FillQWord( var x; count: SizeInt; value: QWord); Bellek bölgesini 64 bit desenle doldurur
15	procedure FillWord( var x; count: SizeInt; Value: Word); Bellek bölgesini 16 bit desenle doldurur
16	procedure Freemem( p: pointer; Size: PtrUInt); Ayrılan belleği serbest bırakır
17	procedure Freemem( p: pointer ); Ayrılan belleği serbest bırakır
18	procedure Getmem( out p: pointer; Size: PtrUInt); Yeni hafıza ayırır
19	procedure Getmem( out p: pointer); Yeni hafıza ayırır
20	procedure GetMemoryManager( var MemMgr: TMemoryManager); Mevcut hafıza yöneticisini döndürür
21	function High( Arg: TypeOrVariable):TOrdinal; Açık dizinin en yüksek dizinini veya numaralandırılmış olarak döndürür
22	function IndexByte( const buf; len: SizeInt; b: Byte):SizeInt; Bir bellek aralığında bayt büyüklüğündeki değeri bulur
23	function IndexChar( const buf; len: SizeInt; b: Char):SizeInt; Bir bellek aralığında karakter boyutunda bir değer bulur
24	function IndexDWord( const buf; len: SizeInt; b: DWord):SizeInt; Bir bellek aralığında DWord boyutlu (32 bit) değeri bulur
25	function IndexQWord( const buf; len: SizeInt; b: QWord):SizeInt; Bir bellek aralığında QWord boyutlu değeri bulur
26	function Indexword( const buf; len: SizeInt; b: Word):SizeInt; Bir bellek aralığında kelime büyüklüğünde değer bulur
27	function IsMemoryManagerSet: Boolean; Hafıza yöneticisi ayarlanmış mı
28	function Low( Arg: TypeOrVariable ):TOrdinal; Açık dizinin en düşük dizinini veya numaralandırılmış olarak verir
29	procedure Move( const source; var dest; count: SizeInt ); Verileri hafızadaki bir konumdan diğerine taşır
30	procedure MoveChar0( const buf1; var buf2; len: SizeInt); Verileri ilk sıfır karakterine kadar taşır
31	procedure New( var P: Pointer); Değişken için dinamik olarak bellek ayırın
32	procedure New( var P: Pointer; Cons: TProcedure); Değişken için dinamik olarak bellek ayırır
33	function Ofs( var X ):LongInt; Değişkenin ofsetini verir
34	function ptr( sel: LongInt; off: LongInt):farpointer; İşaretçiye segment ve ofseti birleştirir
35	function ReAllocMem( var p: pointer; Size: PtrUInt):pointer; Yığın üzerindeki bir bellek bloğunu yeniden boyutlandırır
36	function Seg( var X):LongInt; İade segmenti
37	procedure SetMemoryManager( const MemMgr: TMemoryManager ); Bir hafıza yöneticisi ayarlar
38	function Sptr: Pointer; Mevcut yığın işaretçisini döndürür
39	function Sseg: Word; Yığın segment kayıt değerini döndürür

Bir Pascal programı, birimler adı verilen modüllerden oluşabilir. Bir birim, değişkenlerden ve tür bildirimlerinden, ifadelerden, prosedürlerden vb. Oluşan bazı kod bloklarından oluşabilir. Pascal'da birçok yerleşik birim vardır ve Pascal, programcıların kullanılacak kendi birimlerini tanımlamasına ve yazmasına izin verir. daha sonra çeşitli programlarda.

Yerleşik Üniteleri Kullanma

Hem yerleşik birimler hem de kullanıcı tanımlı birimler, kullanım cümlesi tarafından bir programa dahil edilir. Varyantlar birimini Pascal - Varyantlar öğreticisinde zaten kullandık . Bu eğitimde, kullanıcı tanımlı birimlerin oluşturulması ve dahil edilmesi açıklanmaktadır. Ancak, önce yerleşik bir birimin nasıl ekleneceğini görelim.crt programınızda -

program myprog;
uses crt;

Aşağıdaki örnek, crt birim -

Program Calculate_Area (input, output);
uses crt;
var 
   a, b, c, s, area: real;

begin
   textbackground(white); (* gives a white background *)
   clrscr; (*clears the screen *)
   
   textcolor(green); (* text color is green *)
   gotoxy(30, 4); (* takes the pointer to the 4th line and 30th column) 
   
   writeln('This program calculates area of a triangle:');
   writeln('Area = area = sqrt(s(s-a)(s-b)(s-c))');
   writeln('S stands for semi-perimeter');
   writeln('a, b, c are sides of the triangle');
   writeln('Press any key when you are ready');
   
   readkey;
   clrscr;
   gotoxy(20,3);
   
   write('Enter a: ');
   readln(a);
   gotoxy(20,5);
   
   write('Enter b:');
   readln(b);
   gotoxy(20, 7);
   
   write('Enter c: ');
   readln(c);

   s := (a + b + c)/2.0;
   area := sqrt(s * (s - a)*(s-b)*(s-c));
   gotoxy(20, 9);
   
   writeln('Area: ',area:10:3);
   readkey;
end.

Pascal eğitiminin hemen başında kullandığımız programın aynısı, değişikliğin etkilerini bulmak için onu derleyin ve çalıştırın.

Bir Pascal Birimi Oluşturma ve Kullanma

Bir birim oluşturmak için, içinde saklamak istediğiniz modülleri veya alt programları yazmanız ve bir dosyaya kaydetmeniz gerekir. .pasuzantı. Bu dosyanın ilk satırı, anahtar kelime birimi ile başlamalı ve ardından birimin adı gelmelidir. Örneğin -

unit calculateArea;

Aşağıda, bir Pascal birimi oluşturmanın üç önemli adımı verilmiştir -

• Dosyanın adı ve birimin adı tam olarak aynı olmalıdır. Böylece, calculateArea birimimiz calculateArea.pas adlı bir dosyaya kaydedilecektir .

• Sonraki satır tek bir anahtar kelimeden oluşmalıdır interface. Bu satırdan sonra bu ünitede gelecek olan tüm fonksiyon ve prosedürler için beyanları yazacaksınız.

• İşlev bildirimlerinden hemen sonra kelimesini yazın implementation, yine bir anahtar kelimedir. Anahtar kelime uygulamasını içeren satırdan sonra, tüm alt programların tanımını sağlayın.

Aşağıdaki program, calculateArea adlı birimi oluşturur -

unit CalculateArea;
interface

function RectangleArea( length, width: real): real;
function CircleArea(radius: real) : real;
function TriangleArea( side1, side2, side3: real): real;

implementation

function RectangleArea( length, width: real): real;
begin
   RectangleArea := length * width;
end;

function CircleArea(radius: real) : real;
const
   PI = 3.14159;
begin
   CircleArea := PI * radius * radius;
end;

function TriangleArea( side1, side2, side3: real): real;
var
   s, area: real;

begin
   s := (side1 + side2 + side3)/2.0;
   area := sqrt(s * (s - side1)*(s-side2)*(s-side3));
   TriangleArea := area;
end;

end.

Sonra, yukarıda tanımladığımız birimi kullanacak basit bir program yazalım -

program AreaCalculation;
uses CalculateArea,crt;

var
   l, w, r, a, b, c, area: real;

begin
   clrscr;
   l := 5.4;
   w := 4.7;
   area := RectangleArea(l, w);
   writeln('Area of Rectangle 5.4 x 4.7 is: ', area:7:3);

   r:= 7.0;
   area:= CircleArea(r);
   writeln('Area of Circle with radius 7.0 is: ', area:7:3);

   a := 3.0;
   b:= 4.0;
   c:= 5.0;
  
   area:= TriangleArea(a, b, c);
   writeln('Area of Triangle 3.0 by 4.0 by 5.0 is: ', area:7:3);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Area of Rectangle 5.4 x 4.7 is: 25.380
Area of Circle with radius 7.0 is: 153.938
Area of Triangle 3.0 by 4.0 by 5.0 is: 6.000

Yazdığınız yazılımların çoğu, geçerli tarih ve saati döndüren bazı tarih işlevlerini uygulamaya ihtiyaç duyar. Tarihler, günlük yaşamın o kadar önemli bir parçası ki, onlarla düşünmeden çalışmak kolay hale geliyor. Pascal ayrıca tarih aritmetiği için tarihlerin işlenmesini kolaylaştıran güçlü araçlar sağlar. Ancak, bu işlevlerin gerçek adı ve çalışmaları farklı derleyiciler için farklıdır.

Güncel Tarih ve Saati Alma

Pascal'ın TimeToString işlevi, iki nokta üst üste (:) ile ayrılmış biçimde geçerli zamanı size verir. Aşağıdaki örnek, geçerli saatin nasıl alınacağını gösterir -

program TimeDemo;
uses sysutils;

begin
   writeln ('Current time : ',TimeToStr(Time));
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Current time : 18:33:08

Date işlev şu anki tarihi döndürür TDateTimebiçim. TDateTime, bazı kod çözme ve biçimlendirme gerektiren bir çift değerdir. Aşağıdaki program, geçerli tarihi görüntülemek için programınızda nasıl kullanılacağını gösterir -

Program DateDemo;
uses sysutils;
var
   YY,MM,DD : Word;

begin
   writeln ('Date : ',Date);
   DeCodeDate (Date,YY,MM,DD);
   writeln (format ('Today is (DD/MM/YY): %d/%d/%d ',[dd,mm,yy]));
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Date: 4.111300000000000E+004
Today is (DD/MM/YY):23/7/2012

Şimdi işlevi geçerli tarih ve saati döndürür -

Program DatenTimeDemo;
uses sysutils;
begin
   writeln ('Date and Time at the time of writing : ',DateTimeToStr(Now));
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Date and Time at the time of writing : 23/7/2012 18:51:

Free Pascal adlı basit bir zaman damgası yapısı sağlar TTimeStamp, aşağıdaki biçime sahip olan -

type TTimeStamp = record
   Time: Integer;
   Date: Integer;
end;

Çeşitli Tarih ve Saat İşlevleri

Free Pascal aşağıdaki tarih ve saat işlevlerini sağlar -

Sr.No.	Fonksiyon Adı ve Tanımı
1	function DateTimeToFileDate(DateTime: TDateTime):LongInt; DateTime türünü dosya tarihine dönüştürür.
2	function DateTimeToStr( DateTime: TDateTime):; DateTime'ın dize temsilini oluşturur
3	function DateTimeToStr(DateTime: TDateTime; const FormatSettings: TFormatSettings):; DateTime'ın dize temsilini oluşturur
4	procedure DateTimeToString(out Result: ;const FormatStr: ;const DateTime: TDateTime); DateTime'ın dize temsilini oluşturur
5	procedure DateTimeToString(out Result: ; const FormatStr: ; const DateTime: TDateTime; const FormatSettings: TFormatSettings); DateTime'ın dize temsilini oluşturur
6	procedure DateTimeToSystemTime(DateTime: TDateTime; out SystemTime: TSystemTime); DateTime'ı sistem saatine dönüştürür
7	function DateTimeToTimeStamp( DateTime: TDateTime):TTimeStamp;DateTime'ı zaman damgasına dönüştürür
8	function DateToStr(Date: TDateTime):; Tarihin dize gösterimini oluşturur
9	function DateToStr(Date: TDateTime; const FormatSettings: TFormatSettings):; Tarihin dize gösterimini oluşturur
10	function Date: TDateTime; Geçerli tarihi alır
11	function DayOfWeek(DateTime: TDateTime):Integer; Haftanın gününü alır
12	procedure DecodeDate(Date: TDateTime; out Year: Word; out Month: Word; out Day: Word); DateTime kodunu yıl ay ve gün olarak çözer
13	procedure DecodeTime(Time: TDateTime; out Hour: Word; out Minute: Word; out Second: Word; out MilliSecond: Word); DateTime kodunu saat, dakika ve saniye olarak çözer
14	function EncodeDate(Year: Word; Month: Word; Day: Word):TDateTime; DateTime için yılı, günü ve ayı kodlar
15	function EncodeTime(Hour: Word; Minute: Word; Second: Word; MilliSecond: Word):TDateTime; DateTime saat, dakika ve saniyeyi kodlar
16	function FormatDateTime(const FormatStr: ; DateTime: TDateTime):; DateTime'ın dize gösterimini döndürür
17	function FormatDateTime(const FormatStr: ; DateTime: TDateTime; const FormatSettings: TFormatSettings):; DateTime'ın dize gösterimini döndürür
18	function IncMonth(const DateTime: TDateTime; NumberOfMonths: Integer = 1):TDateTime; Ayda 1 ekler
19	function IsLeapYear(Year: Word):Boolean; Yılın artık yıl olup olmadığını belirler
20	function MSecsToTimeStamp(MSecs: Comp):TTimeStamp; Milisaniye sayısını zaman damgasına dönüştürür
21	function Now: TDateTime; Geçerli tarih ve saati alır
22	function StrToDateTime(const S:):TDateTime; Dizeyi DateTime'a dönüştürür
23	function StrToDateTime(const s: ShortString; const FormatSettings: TFormatSettings):TDateTime; Dizeyi DateTime'a dönüştürür
24	function StrToDateTime(const s: AnsiString; const FormatSettings: TFormatSettings):TDateTime; Dizeyi DateTime'a dönüştürür
25	function StrToDate(const S: ShortString):TDateTime; Dizeyi tarihe dönüştürür
26	function StrToDate(const S: Ansistring):TDateTime; Dizeyi tarihe dönüştürür
27	function StrToDate(const S: ShortString; separator: Char):TDateTime; Dizeyi tarihe dönüştürür
28	function StrToDate(const S: AnsiString; separator: Char):TDateTime; Dizeyi tarihe dönüştürür
29	function StrToDate(const S: ShortString; const useformat: ; separator: Char):TDateTime; Dizeyi tarihe dönüştürür
30	function StrToDate(const S: AnsiString; const useformat: ; separator: Char):TDateTime; Dizeyi tarihe dönüştürür
31	function StrToDate(const S: PChar; Len: Integer; const useformat: ; separator: Char = #0):TDateTime; Dizeyi tarihe dönüştürür
32	function StrToTime(const S: Shortstring):TDateTime; Dizeyi zamana dönüştürür
33	function StrToTime(const S: Ansistring):TDateTime; Dizeyi zamana dönüştürür
34	function StrToTime(const S: ShortString; separator: Char):TDateTime; Dizeyi zamana dönüştürür
35	function StrToTime(const S: AnsiString; separator: Char):TDateTime; Dizeyi zamana dönüştürür
36	function StrToTime(const S: ; FormatSettings: TFormatSettings):TDateTime; Dizeyi zamana dönüştürür
37	function StrToTime(const S: PChar; Len: Integer; separator: Char = #0):TDateTime; Dizeyi zamana dönüştürür
38	function SystemTimeToDateTime(const SystemTime: TSystemTime):TDateTime; Sistem zamanını tarih saatine dönüştürür
39	function TimeStampToDateTime(const TimeStamp: TTimeStamp):TDateTime; Zaman damgasını DateTime'a dönüştürür
40	function TimeStampToMSecs(const TimeStamp: TTimeStamp):comp; Zaman Damgasını milisaniye sayısına dönüştürür
41	function TimeToStr(Time: TDateTime):; Zamanın dize gösterimini döndürür
42	function TimeToStr(Time: TDateTime; const FormatSettings: TFormatSettings):; Zamanın dize gösterimini döndürür
43	function Time: TDateTime; Geçerli zamanı alın

Aşağıdaki örnek, yukarıdaki işlevlerden bazılarının kullanımını göstermektedir -

Program DatenTimeDemo;
uses sysutils;
var
year, month, day, hr, min, sec, ms: Word;

begin
   writeln ('Date and Time at the time of writing : ',DateTimeToStr(Now));
   writeln('Today is ',LongDayNames[DayOfWeek(Date)]);
   writeln;
   writeln('Details of Date: ');
   
   DecodeDate(Date,year,month,day);
   writeln (Format ('Day: %d',[day]));
   writeln (Format ('Month: %d',[month]));
   writeln (Format ('Year: %d',[year]));
   writeln;
   writeln('Details of Time: ');
   
   DecodeTime(Time,hr, min, sec, ms);
   writeln (format('Hour: %d:',[hr]));
   writeln (format('Minutes: %d:',[min]));
   writeln (format('Seconds: %d:',[sec]));
   writeln (format('Milliseconds: %d:',[hr]));
end.

Yukarıdaki kod derlenip çalıştırıldığında aşağıdaki sonucu verdi:

Date and Time at the time of writing : 7/24/2012 8:26:
Today is Tuesday
Details of Date:
Day:24
Month:7
Year: 2012
Details of Time:
Hour: 8
Minutes: 26
Seconds: 21
Milliseconds: 8

Evrenimizin güneş, dünya, ay vb. Gibi farklı nesnelerden oluştuğunu hayal edebiliriz. Benzer şekilde, arabamızı tekerlek, direksiyon, dişli vb. Gibi farklı nesnelerden yapılmış hayal edebiliriz. Aynı şekilde, nesne tabanlı programlama konseptleri vardır. her şeyi bir nesne olarak varsayın ve farklı nesneler kullanarak bir yazılım gerçekleştirin. Pascal'da, gerçek dünya nesnesini uygulamak için kullanılan iki yapısal veri türü vardır -

• Nesne türleri
• Sınıf türleri

Nesneye Yönelik Kavramlar

Ayrıntıya girmeden önce, Nesne Tabanlı Pascal ile ilgili önemli Pascal terimlerini tanımlayalım.

• Object- Nesne, kayıt gibi alanlar içeren özel bir kayıt türüdür; ancak, kayıtlardan farklı olarak nesneler, nesnenin parçası olarak prosedürler ve işlevler içerir. Bu prosedürler ve işlevler, nesnenin türüyle ilişkili yöntemlere işaret eder.

• Class- Bir Sınıf, neredeyse bir Nesne ile aynı şekilde tanımlanır, ancak yaratılma şekillerinde bir fark vardır. Sınıf, bir programın Yığını üzerinde tahsis edilirken, Nesne Yığın üzerinde tahsis edilir. Nesnenin kendisine değil, nesneye bir göstericidir.

• Instantiation of a class- Örnekleme, bu sınıf türünde bir değişken oluşturmak anlamına gelir. Bir sınıf yalnızca bir işaretçi olduğundan, sınıf türünden bir değişken bildirildiğinde, tüm nesne için değil, yalnızca işaretçi için ayrılmış bellek vardır. Yalnızca kurucularından biri kullanılarak somutlaştırıldığında, nesne için bellek ayrılır. Bir sınıfın örneklerine 'nesneler' de denir, ancak bunları Object Pascal Nesneleri ile karıştırmayın. Bu eğitimde, Pascal Nesneleri için 'Nesne' ve kavramsal nesne veya sınıf örneği için 'nesne' yazacağız.

• Member Variables - Bunlar bir Sınıf veya Nesne içinde tanımlanan değişkenlerdir.

• Member Functions - Bunlar, bir Sınıf veya Nesne içinde tanımlanan işlevler veya prosedürlerdir ve nesne verilerine erişmek için kullanılır.

• Visibility of Members- Bir Nesnenin veya Sınıfın üyelerine alanlar da denir. Bu alanların farklı görünürlükleri vardır. Görünürlük, üyelerin erişilebilirliği, yani bu üyelerin tam olarak nerede erişilebilir olacağı anlamına gelir. Nesnelerin üç görünürlük düzeyi vardır: genel, özel ve korumalı. Sınıfların beş görünürlük türü vardır: genel, özel, kesinlikle özel, korumalı ve yayınlanmış. Görünürlüğü ayrıntılı olarak tartışacağız.

• Inheritance- Bir Sınıf, bir üst Sınıfın mevcut işlevlerini miras alarak tanımlandığında, miras alındığı söylenir. Burada alt sınıf, bir üst sınıfın tüm veya birkaç üye işlevini ve değişkenini miras alır. Nesneler de miras alınabilir.

• Parent Class- Başka bir Sınıf tarafından miras alınan bir Sınıf. Buna temel sınıf veya süper sınıf da denir.

• Child Class- Başka bir sınıftan miras alan bir sınıf. Buna alt sınıf veya türetilmiş sınıf da denir.

• Polymorphism- Bu, aynı işlevin farklı amaçlar için kullanılabileceği nesne yönelimli bir kavramdır. Örneğin, işlev adı aynı kalacaktır ancak farklı sayıda argüman alabilir ve farklı görevler yapabilir. Pascal sınıfları polimorfizmi uygular. Nesneler çok biçimlilik uygulamaz.

• Overloading- Operatörlerin bazılarının veya tamamının argümanlarının türüne bağlı olarak farklı uygulamalara sahip olduğu bir polimorfizm türüdür. Benzer şekilde, farklı uygulamalarla işlevler de aşırı yüklenebilir. Pascal sınıfları aşırı yükleme uygular, ancak Nesneler bunu yapmaz.

• Data Abstraction - Uygulama ayrıntılarının gizlendiği (soyutlandığı) herhangi bir veri temsili.

• Encapsulation - Bir nesne oluşturmak için tüm verileri ve üye işlevlerini birlikte kapsüllediğimiz bir kavramı ifade eder.

• Constructor - Bir sınıftan veya bir Nesneden bir nesne oluşumu olduğunda otomatik olarak çağrılacak özel bir işlev türünü ifade eder.

• Destructor - Bir Nesne veya Sınıf silindiğinde veya kapsam dışına çıktığında otomatik olarak çağrılacak özel bir işlev türünü ifade eder.

Pascal Nesnelerini Tanımlama

Tür bildirimi kullanılarak bir nesne bildirilir. Bir nesne bildiriminin genel biçimi aşağıdaki gibidir -

type object-identifier = object  
   private
   field1 : field-type;  
   field2 : field-type;  
   ...
   public
   procedure proc1;  
   function f1(): function-type;
   end;  
var objectvar : object-identifier;

İki tamsayı türü veri üyesine sahip bir Dikdörtgen Nesnesi tanımlayalım - length ve width ve bu veri üyelerini işlemek için bazı üye fonksiyonları ve dikdörtgeni çizmek için bir prosedür.

type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      constructor init;  
      destructor done;  
      
      procedure setlength(l: inteter);  
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

Nesnelerinizi oluşturduktan sonra, o nesneyle ilgili üye işlevleri çağırabileceksiniz. Bir üye fonksiyon sadece ilgili nesnenin üye değişkenini işleyebilecektir.

Aşağıdaki örnek, iki dikdörtgen nesne için uzunluk ve genişliklerin nasıl ayarlanacağını ve üye işlevlerini çağırarak nasıl çizileceğini gösterir.

r1.setlength(3);
r1.setwidth(7);

writeln(' Draw a rectangle: ', r1.getlength(), ' by ' , r1.getwidth());
r1.draw;
new(pr1);
pr1^.setlength(5);
pr1^.setwidth(4);

writeln(' Draw a rectangle: ', pr1^.getlength(), ' by ' ,pr1^.getwidth());
pr1^.draw;
dispose(pr1);

Aşağıda, Pascal'da nesnelerin nasıl kullanılacağını gösteren eksiksiz bir örnek verilmiştir -

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
     for j:= 1 to width do
        write(' * ');
     writeln;
   end;
end;

begin
   r1.setlength(3);
   r1.setwidth(7);
   
   writeln('Draw a rectangle:', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   new(pr1);
   pr1^.setlength(5);
   pr1^.setwidth(4);
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *

Nesne Üyelerinin Görünürlüğü

Görünürlük, nesne üyelerinin erişilebilirliğini gösterir. Pascal nesne üyelerinin üç tür görünürlüğü vardır -

Sr.No	Görünürlük ve Erişilebilirlik
1	Public Üyeler, program birimi dışındaki diğer birimler tarafından kullanılabilir.
2	Private Üyelere yalnızca mevcut birimde erişilebilir.
3	Protected Üyeler, yalnızca üst nesneden gelen nesneler için kullanılabilir.

Varsayılan olarak, bir nesnenin alanları ve yöntemleri geneldir ve geçerli birimin dışına aktarılır.

Pascal Nesneleri için Oluşturucular ve Yıkıcılar -

Constructorsbir nesne oluşturulduğunda otomatik olarak çağrılan özel tür yöntemlerdir. Pascal'da bir anahtar kelime yapıcısı ile bir yöntem bildirerek bir kurucu oluşturursunuz. Geleneksel olarak, yöntem adı Init'tir, ancak kendi geçerli herhangi bir tanımlayıcınızı sağlayabilirsiniz. Yapıcı işlevine istediğiniz kadar argüman iletebilirsiniz.

Destructorsnesnenin yok edilmesi sırasında çağrılan yöntemlerdir. Yıkıcı yöntemler, yapıcılar tarafından oluşturulan herhangi bir bellek tahsisini yok eder.

Aşağıdaki örnek, nesne oluşturma sırasında dikdörtgenin uzunluğunu ve genişliğini başlatacak ve kapsam dışına çıktığında onu yok edecek Rectangle sınıfı için bir kurucu ve bir yıkıcı sağlayacaktır.

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      constructor init(l, w: integer);
      destructor done;
      
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;

var
   r1: Rectangle;
   pr1: ^Rectangle;

constructor Rectangle.init(l, w: integer);
begin
   length := l;
   width := w;
end;

destructor Rectangle.done;
begin
   writeln(' Desctructor Called');
end; 

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
   end;
end;

begin
   r1.init(3, 7);
   writeln('Draw a rectangle:', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   new(pr1, init(5, 4));
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ',pr1^.getwidth());
   pr1^.draw;
   pr1^.init(7, 9);
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
   r1.done;
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *
Draw a rectangle: 7 by 9
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
Destructor Called

Pascal Nesneleri için Kalıtım

Pascal nesneleri isteğe bağlı olarak bir üst nesneden miras alabilir. Aşağıdaki program, Pascal Nesnelerindeki kalıtımı göstermektedir. Adlı başka bir nesne oluşturalımTableTop, Rectangle nesnesinden miras alır.

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      procedure setlength(l: integer);  
      function getlength(): integer;  
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      procedure draw;
end;

TableTop = object (Rectangle)
   private
     material: string;
   public
      function getmaterial(): string;
      procedure setmaterial( m: string);
      procedure displaydetails;
      procedure draw;
end;

var
   tt1: TableTop;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth():integer;
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
  end;
end;

function TableTop.getmaterial(): string;
begin
   getmaterial := material;
end;

procedure TableTop.setmaterial( m: string);
begin
   material := m;
end;

procedure TableTop.displaydetails;
begin
   writeln('Table Top: ', self.getlength(), ' by ' , self.getwidth());
   writeln('Material: ', self.getmaterial());
end;

procedure TableTop.draw();
var
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
   writeln;
   end;
   writeln('Material: ', material);
end;

begin
   tt1.setlength(3);
   tt1.setwidth(7);
   tt1.setmaterial('Wood');
   tt1.displaydetails();
   writeln;
   writeln('Calling the Draw method');
   tt1.draw();
end.

Dikkat edilmesi gereken önemli noktalar aşağıdadır:

• Nesne Masa Dikdörtgen nesnesinin tüm üyelerini miras aldı.

• TableTop'ta da bir çizim yöntemi var . Ne zaman beraberlik yöntemi kullanılarak denir TableTop nesnesi, masa en beraberlik yaþamageçirilir.

• Adında örtük bir örnek var self nesnenin geçerli örneğini ifade eder.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Table Top: 3 by 7
Material: Wood

Calling the Draw Method 
* * * * * * *
* * * * * * *
* * * * * * *
Material: Wood

Pascal Objects'in nesne yönelimli paradigmanın bazı özelliklerini sergilediğini gördünüz. Kapsülleme, veri gizleme ve kalıtım uygularlar, ancak aynı zamanda sınırlamaları da vardır. Örneğin, Pascal Nesneleri polimorfizmde yer almaz. Bu nedenle sınıflar, bir programda, özellikle GUI tabanlı yazılımda uygun nesne yönelimli davranışı uygulamak için yaygın olarak kullanılır.

Bir Sınıf, neredeyse bir Nesne ile aynı şekilde tanımlanır, ancak Nesnenin kendisinden ziyade bir Nesneye bir göstericidir. Teknik olarak bu, Sınıfın bir programın Yığına tahsis edildiği, Nesnenin ise Yığın üzerinde tahsis edildiği anlamına gelir. Başka bir deyişle, bir değişkeni nesne türü olarak bildirdiğinizde, yığın üzerinde nesnenin boyutu kadar yer kaplar, ancak sınıf türünden bir değişken bildirdiğinizde, her zaman bir işaretçinin boyutunu alır. yığın üzerinde. Gerçek sınıf verileri yığın üzerinde olacaktır.

Pascal Sınıflarını Tanımlama

Bir sınıf, tür bildirimi kullanılarak bir nesneyle aynı şekilde bildirilir. Bir sınıf bildiriminin genel şekli aşağıdaki gibidir -

type class-identifier = class  
   private
      field1 : field-type;  
      field2 : field-type;  
        ...
   
   public
      constructor create();
      procedure proc1;  
      function f1(): function-type;
end;  
var classvar : class-identifier;

Aşağıdaki önemli noktaları dikkate almaya değer -

• Sınıf tanımları, programın yalnızca tür bildirimi bölümünde yer almalıdır.

• Bir sınıf, class anahtar kelime.

• Alanlar, sınıfın her bir örneğinde bulunan veri öğeleridir.

• Yöntemler, bir sınıfın tanımı içinde bildirilir.

• Adında önceden tanımlanmış bir kurucu var CreateRoot sınıfında. Her soyut sınıf ve her somut sınıf, Root'un soyundan gelir, bu nedenle tüm sınıfların en az bir kurucusu vardır.

• Adında önceden tanımlanmış bir yıkıcı var DestroyRoot sınıfında. Her soyut sınıf ve her somut sınıf Root'un soyundan gelir, bu nedenle tüm sınıfların en az bir yıkıcısı vardır.

İki tamsayı türü veri üyesine sahip bir Rectangle sınıfı tanımlayalım - uzunluk ve genişlik ve bu veri üyelerini işlemek için bazı üye işlevleri ve dikdörtgeni çizmek için bir prosedür.

type
   Rectangle = class
   private
      length, width: integer;
   
   public
      constructor create(l, w: integer);
      procedure setlength(l: integer);
      function getlength(): integer;
      procedure setwidth(w: integer);
      function getwidth(): integer;
      procedure draw;
end;

Dikdörtgen sınıfının bir örneğini yaratacak ve dikdörtgeni çizecek eksiksiz bir program yazalım. Bu, Pascal Nesnelerini tartışırken kullandığımız örnekle aynıdır. Aşağıdaki istisnalar dışında her iki programın da neredeyse aynı olduğunu göreceksiniz -

• Sınıfları kullanmak için {$ mode objfpc} direktifini eklemeniz gerekecek.

• Yapıcıları kullanmak için {$ m +} direktifini eklemeniz gerekecek.

• Sınıf somutlaştırması nesne somutlaştırmasından farklıdır. Yalnızca değişkeni bildirmek örnek için alan yaratmaz, oluşturucuyu bellek ayırmak için kullanırsınız.

İşte tam örnek -

{$mode objfpc} // directive to be used for defining classes {$m+}		   // directive to be used for using constructor

program exClass;
type
   Rectangle = class
   private
      length, width: integer;
   
   public
      constructor create(l, w: integer);
      procedure setlength(l: integer);
      
      function getlength(): integer;
      procedure setwidth(w: integer);
      
      function getwidth(): integer;
      procedure draw;
end;
var
   r1: Rectangle;

constructor Rectangle.create(l, w: integer);
begin
   length := l;
   width := w;
end;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
   end;
end;

begin
   r1:= Rectangle.create(3, 7);
   
   writeln(' Draw Rectangle: ', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   r1.setlength(4);
   r1.setwidth(6);
   
   writeln(' Draw Rectangle: ', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Draw Rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw Rectangle: 4 by 6
* * * * * * 
* * * * * * 
* * * * * * 
* * * * * *

Sınıf Üyelerinin Görünürlüğü

Görünürlük, sınıf üyelerinin erişilebilirliğini gösterir. Pascal sınıfı üyelerinin beş tür görünürlük vardır -

Sr.No	Görünürlük ve Erişilebilirlik
1	Public Bu üyelere her zaman erişilebilir.
2	Private Bu üyelere yalnızca sınıf tanımını içeren modül veya birimden erişilebilir. Sınıf yöntemlerinin içinden veya dışından erişilebilirler.
3	Strict Private Bu üyelere yalnızca sınıfın kendi yöntemlerinden erişilebilir. Aynı ünitedeki diğer sınıflar veya alt sınıflar bunlara erişemez.
4	Protected Bu, özel ile aynıdır, ancak bu üyelere, diğer modüllerde uygulanmış olsalar bile alt türler tarafından erişilebilir.
5	Published Bu, Genel ile aynıdır, ancak derleyici, {$ M +} durumundaysa, bu sınıfların otomatik akışı için gereken tür bilgilerini üretir. Yayınlanmış bir bölümde tanımlanan alanlar sınıf türünde olmalıdır.

Pascal Sınıfları için Oluşturucular ve Yıkıcılar

Yapıcılar, bir nesne oluşturulduğunda otomatik olarak çağrılan özel yöntemlerdir. Bu nedenle, birçok şeyi yapıcı işlevler aracılığıyla başlatarak bu davranıştan tam olarak yararlanıyoruz.

Pascal, bir yapıcı tanımlamak için create () adında özel bir işlev sağlar. Yapıcı işlevine istediğiniz kadar argüman iletebilirsiniz.

Aşağıdaki örnek, Books adında bir sınıf için bir kurucu oluşturacak ve nesne oluşturma sırasında kitap için fiyatı ve başlığı başlatacaktır.

program classExample;

{$MODE OBJFPC} //directive to be used for creating classes
{$M+} //directive that allows class constructors and destructors
type
   Books = Class 
   private 
      title : String; 
      price: real;
   
   public
      constructor Create(t : String; p: real); //default constructor
      
      procedure setTitle(t : String); //sets title for a book
      function getTitle() : String; //retrieves title
      
      procedure setPrice(p : real); //sets price for a book
      function getPrice() : real; //retrieves price
      
      procedure Display(); // display details of a book
end;
var
   physics, chemistry, maths: Books;

//default constructor 
constructor Books.Create(t : String; p: real);
begin
   title := t;
   price := p;
end;

procedure Books.setTitle(t : String); //sets title for a book
begin
   title := t;
end;

function Books.getTitle() : String; //retrieves title
begin
   getTitle := title;
end;

procedure Books.setPrice(p : real); //sets price for a book
begin
   price := p;
end;

function Books.getPrice() : real; //retrieves price
begin
   getPrice:= price;
end;

procedure Books.Display();
begin
   writeln('Title: ', title);
   writeln('Price: ', price:5:2);
end;

begin 
   physics := Books.Create('Physics for High School', 10);
   chemistry := Books.Create('Advanced Chemistry', 15);
   maths := Books.Create('Algebra', 7);
   
   physics.Display;
   chemistry.Display;
   maths.Display;
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Title: Physics for High School
Price: 10
Title: Advanced Chemistry
Price: 15
Title: Algebra
Price: 7

Create adlı örtük kurucu gibi, sınıfta kullanılan tüm kaynakları serbest bırakabileceğiniz bir de yok etme örtük yıkıcı yöntemi vardır.

Miras

Pascal sınıf tanımları isteğe bağlı olarak bir üst sınıf tanımından miras alabilir. Sözdizimi aşağıdaki gibidir -

type
childClas-identifier = class(baseClass-identifier) 
< members >
end;

Aşağıdaki örnek, Books sınıfını devralan ve gereksinime göre daha fazla işlevsellik ekleyen bir roman sınıfı sağlar.

program inheritanceExample;

{$MODE OBJFPC} //directive to be used for creating classes
{$M+} //directive that allows class constructors and destructors

type
   Books = Class 
   protected 
      title : String; 
      price: real;
   
   public
      constructor Create(t : String; p: real); //default constructor
      
      procedure setTitle(t : String); //sets title for a book
      function getTitle() : String; //retrieves title
      
      procedure setPrice(p : real); //sets price for a book
      function getPrice() : real; //retrieves price
      
      procedure Display(); virtual; // display details of a book
end;
(* Creating a derived class *)

type
   Novels = Class(Books)
   private
      author: String;
   
   public
      constructor Create(t: String); overload;
      constructor Create(a: String; t: String; p: real); overload;
      
      procedure setAuthor(a: String); // sets author for a book
      function getAuthor(): String; // retrieves author name
      
      procedure Display(); override;
end;
var
   n1, n2: Novels;

//default constructor 
constructor Books.Create(t : String; p: real);
begin
   title := t;
   price := p;
end;

procedure Books.setTitle(t : String); //sets title for a book
begin
   title := t;
end;

function Books.getTitle() : String; //retrieves title
begin
   getTitle := title;
end;

procedure Books.setPrice(p : real); //sets price for a book
begin
   price := p;
end;

function Books.getPrice() : real; //retrieves price
begin
   getPrice:= price;
end;

procedure Books.Display();
begin
   writeln('Title: ', title);
   writeln('Price: ', price);
end;

(* Now the derived class methods  *)
constructor Novels.Create(t: String);
begin
   inherited Create(t, 0.0);
   author:= ' ';
end;

constructor Novels.Create(a: String; t: String; p: real);
begin
   inherited Create(t, p);
   author:= a;
end;

procedure Novels.setAuthor(a : String); //sets author for a book
begin
   author := a;
end;

function Novels.getAuthor() : String; //retrieves author
begin
   getAuthor := author;
end;

procedure Novels.Display();
begin
   writeln('Title: ', title);
   writeln('Price: ', price:5:2);
   writeln('Author: ', author);
end;

begin 
   n1 := Novels.Create('Gone with the Wind');
   n2 := Novels.Create('Ayn Rand','Atlas Shrugged', 467.75);
   n1.setAuthor('Margaret Mitchell');
   n1.setPrice(375.99);
   n1.Display;
   n2.Display;
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Title: Gone with the Wind
Price: 375.99
Author: Margaret Mitchell
Title: Atlas Shrugged
Price: 467.75
Author: Ayn Rand

Aşağıdaki önemli noktaları dikkate almaya değer -

• Books sınıfının üyeleri protected görünürlük.

• Romanlar sınıfının iki kurucusu vardır, bu nedenle overload operatör, fonksiyon aşırı yüklemesi için kullanılır.

• Books.Display prosedürü ilan edildi virtual, böylece Novels sınıfındaki aynı yöntem override o.

• Novels.Create yapıcısı, temel sınıf yapıcısını kullanarak inherited anahtar kelime.

Arayüzler

Arayüzler, uygulayıcılara ortak bir işlev adı sağlamak için tanımlanır. Farklı uygulayıcılar bu arayüzleri gereksinimlerine göre uygulayabilir. Arayüzler, geliştiriciler tarafından uygulanan iskeletlerdir diyebilirsiniz. Aşağıda bir arayüz örneği verilmiştir -

type  
   Mail = Interface  
      Procedure SendMail;  
      Procedure GetMail;  
   end;  
   
   Report = Class(TInterfacedObject,  Mail)  
      Procedure SendMail;  
      Procedure GetMail;  
   end;

Bir sınıf bir arabirim uyguladığında, arabirimin tüm yöntemlerini uygulaması gerektiğini lütfen unutmayın. Bir arabirim yöntemi uygulanmazsa, derleyici bir hata verecektir.

Soyut Sınıflar

Soyut bir sınıf, somutlaştırılamayan, yalnızca miras alınan bir sınıftır. Soyut bir sınıf, bunun gibi, sınıf tanımına sembol soyut kelimesi eklenerek belirtilir -

type
   Shape = ABSTRACT CLASS (Root)
      Procedure draw; ABSTRACT;
      ...
   end;

Soyut bir sınıftan miras alırken, ebeveynin sınıf bildiriminde soyut olarak işaretlenmiş tüm yöntemler çocuk tarafından tanımlanmalıdır; ayrıca bu yöntemler aynı görünürlükle tanımlanmalıdır.

Statik Anahtar Kelime

Sınıf üyelerini veya yöntemleri statik olarak bildirmek, sınıfın somutlaştırılmasına gerek kalmadan onları erişilebilir kılar. Statik olarak bildirilen bir üyeye, başlatılmış bir sınıf nesnesiyle erişilemez (ancak statik bir yöntem olabilir). Aşağıdaki örnek kavramı göstermektedir -

program StaticExample;
{$mode objfpc}
{$static on}
type
   myclass=class
      num : integer;static;
   end;
var
   n1, n2 : myclass;
begin
   n1:= myclass.create;
   n2:= myclass.create;
   n1.num := 12;
   writeln(n2.num);
   n2.num := 31;
   writeln(n1.num);
   writeln(myclass.num);
   myclass.num := myclass.num + 20;
   writeln(n1.num);
   writeln(n2.num);
end.

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

12
31
31
51
51

Statik üyeleri kullanmak için {$ static on} yönergesini kullanmalısınız.