JĘZYKI I PARADYGMATY PROGRAMOWANIA PROGRAMOWANIA ZMIENNE, TYPY I PODPROGRAMY

JĘZYKI I PARADYGMATY JĘZYKI I PROGRAMOWANIA PARADYGMATY PROGRAMOWANIA ZMIENNE, TYPY I PODPROGRAMY

Plan Translatory Zmienne Wiązania Wiązanie typu Wiązanie pamięci Sprawdzanie zgodności typów Języki silnie typowane Jak zdefiniować zgodność typów Zakres widoczności Zakres statyczny Zakres dynamiczny

Plan Zakres widoczności, a okres życia Typy Abstrakcyjne typy danych Podprogramy Sposoby przekazywania parametrów

Translator Program działający na kodzie źródłowym, którego zadaniem jest przetłumaczenie kodu źródłowego na język zrozumiały dla procesora (wykonawcy programu) Typy translatorów: kompilator asembler interpretator (interpreter)

Język kompilowany Język kompilowany: Język, który wymaga kompilatora w celu przekształcenia za jednym zamachem kodu źródłowego (jako całości) zapisanego w języku wysokiego poziomu w wykonywalny kod binarny (krok 1- kompilacja). Program po przetłumaczeniu jest statyczny (tzn. nie może się zmienić) i może być dalej (po konsolidacji- dołączeniu funkcji bibliotecznych) wielokrotnie wykonywany (krok 2) na maszynie docelowej (uruchamiany jest z poziomu systemu operacyjnego) (np. z zastosowaniem różnych danych wejściowych). Języki kompilowalne: np. C++

Przykład. Generowanie kodu wynikowego dla pliku hello.c z zastosowaniem kompilatora GNU C and C++ $ gcc -v hello.c -o hello.exe -v - opcja verbose wyświetla komunikaty w czasie kompilacji Plik źródłowy (.c (.cpp).h) Krok 1 Preprocessor (cpp) preprocessing $ cpp hello.c > hello.i Plik wynikowy preprocesora zawierający rozszerzenia pliku źródłowego (.i (.ii)) Krok 2 Kompilator (gcc (g++)) kompilacja $ gcc -S hello.i Kod asemblerowy (.s) Krok 3 Asembler (as) assembly $ as -o hello.o hello.s Kod maszynowy (.o (.obj)) Krok 4 Linker (ld) linkowanie (dołączenie bibliotek statycznych (.lib.a)) $ ld -o hello.exe hello.o...libraries... Kod wynikowy (hello.exe)

Język kompilowalny Zalety: najszybszy kod wykonywalny (lepsza optymalizacja kodu dedykowana pod daną architekturę sprzętową) najbardziej kompletny dostęp do systemu operacyjnego do wykonania programu wynikowego nie jest potrzebny kompilator Wady: do kompilacji potrzebny jest kompilator (koszty) relatywnie trudno w nim programować

Asembler Język powstał na bazie języków maszynowych danego procesora poprzez zamianę kodów operacji mnemonikami zawiera podstawowe operacje procesora. jedno polecenie asemblera = jeden rozkaz procesora

Asembler Zalety: wysoka wydajność kodów wynikowych mały rozmiar kodów wynikowych Zastosowanie: programowanie mikrokontrolerów systemy wbudowane (embedded systems) sterowniki sprzętu

Język interpretowany Język, który wymaga interpretatora (tzn. środowiska uruchomieniowego), w którym interpretowany program jest przekształcany w locie z kodu źródłowego do wykonywalnego kodu binarnego podczas każdorazowego jego wykonywania (brak pliku wykonywalnego). Języki interpretowane (nie wymagają kompilacji): np. Ruby

Przykład 1. Interpretowanie kodu źródłowego języka Ruby hello.rb $ ruby hello.rb Inna opcja: użycie trybu interaktywnego (Interactive Ruby) (irb) Przykład 2. $ irb >1 + 2 =>3

Język interpretowany Zalety: nie wymaga kompilatora łatwiej dokonywać zmian programu łatwiej w nim programować mniejsze zużycie pamięci zewnętrznej (tylko kod źródłowy) możliwość pracy konwersacyjnej (zatrzymanie wykonywania zmiana wartości zmiennych kontynuacja wykonywania) Wady: stosunkowo wolny kod wykonywalny ograniczony dostęp do systemu operacyjnego

Języki pseudokodu (P-code) Rodzaj hybrydowych języków używających zarówno kompilacji, jak i interpretacji (patforma uruchomieniowa) Kod źródłowy jest tłumaczony na formę pośrednią- w postaci bajtkodu (pseudokodu) (tzw. P-code) (portable code) (a nie kodu maszynowego). Uruchomienie programu = interpretowanie (tego) pseudokodu Język pseudokodu: np. Java

Języki pseudokodu (P-code) Zalety: pseudokod może działać tylko nieznacznie wolniej niż skompilowany plik binarny elastyczność i moc dobrego interpretera

C (GCC)- generowanie kodu wynikowego i jego wykonywanie hello.cpp #include <ctime> #include <iostream> using namespace std; int main(){ time_t teraz; time(&teraz); cout << "Hello C++: " << ctime(&teraz) << endl; return 0; } Generowanie kodu wynikowego: g++ -o hello.exe hello.c Wykonanie: hello.exe Output: Hello C++: Wed Mar 20 14:11:10 2013

Java- generowanie bytecodu i jego interpretowanie platforma uruchmieniowa JVM (Java Virtual Machine). Java compiler (javac) przekształca java code (.java) na JVM Bytecode (.class). % javac plik.java java.class interpreter wykonuje Bytecode. % java plik nie wprowadzamy rozszerzenia.class Output:... Just-In-Time (JIT) compiler przekształca Bytecode na natywny kod maszynowy

Java- przykład hello.java import java.io.* public class hello { public static void main(string[] args) { System.out.printf( Hello Java: %tc, new java.util.date()); } } javac hello.java generowanie bytecode java hello interpretowanie bytecode Output: Hello Java: śr mar 20 14:14:23 CET 2013

Ruby (irb)- przykład irb(main):001:0> puts "Hello Ruby:" Hello Ruby: => nil irb(main):002:0> Time.now => 2013-03-20 14:20:01 +0100

Architektura von Neumanna Podstawowe elementy architektury von Neumanna: procesor pamięć

Abstrakcyjne mechanizmy Zmienne abstrakcja komórek pamięci: programista może przechowywać dane w pamięci, nie martwiąc się o techniczne szczegóły (np. przydział pamięci) zależność między zmiennymi, a komórkami pamięci może być różna

Zmienne, a komórki pamięci Język C char a; int b; float c[100][100]; sizeof(a) 1 bajt sizeof(b) 4 bajty (maszyna 32-bitowa) sizeof(c) 40 000 bajtów (!)

Zmienne 6 atrybutów: nazwa adres wartość typ okres życia zakres widoczności

Zmienne Atrybut Nazwa cecha rozmaitych bytów (nie tylko zmiennych) szczegół techniczny, nie mający nic wspólnego z przyjętym paradygmatem programowania jakie znaki są dozwolone w nazwach? tradycyjnie- litery, cyfry, znak podkreślenia znaki z zestawu Unicode- język Ada (2005)) liczba dozwolonych znaków (brak istotnych ograniczeń) rozróżnialność dużych i małych liter (język C)

Zmienne Nazwa rozróżnialność dużych i małych liter (język C) Przykład: #include <stdio.h> int main() { char a; int A; printf("size of char: %d\n", sizeof(a)); printf("size of int: %d\n", sizeof(a)); return 0; }

Zmienne Nazwa nie każda zmienna ma nazwę: przydzielając dynamicznie pamięć za pomocą operatora new (w języku C++) tworzymy zmienną bez nazwy Przykład (C++) //przyklad braku nazwy zmiennej, nazwa dotyczy wskaznika int *p_var = new int;

Zmienne Atrybut Adres (l-wartość) (left value) (a nazwa): program może zawierać dwie różne zmienne o tej samej nazwie, nie mające ze sobą nic wspólnego, np. dwie zmienne lokalne w dwóch różnych podprogramach (funkcjach, procedurach, metodach, itp.)

Zmienne Różne zmienne o tej samej nazwie: Przykład (język C) #include <stdio.h> void delta(int a, int b, int c) { int delta = b*b-4*a*c; printf("delta wynosi: %d\n", delta); } void szescian (int a) { int szescian = a*a*a; printf("szescian wynosi: %d\n", szescian); } int main() { delta(5,3,4); szescian(3); return 0; }

Zmienne Adres ta sama zmienna lokalna może mieć różne adresy w czasie różnych wywołań tego samego podprogramu

Zmienne Różne adresy zmiennej: Przykład (język C) #include <stdio.h> void delta(int a, int b, int c) { int delta = b*b-4*a*c; printf("delta wynosi: %d\n", delta); } void szescian (int a) { int szescian = a*a*a; printf("szescian wynosi: %d\n", szescian); } //wywołanie 1 //wywołanie 2 int main() { delta(5,4,3); szescian(3); delta(7,8,9); return 0; }

Zmienne Adres brak jest zatem jednoznacznej odpowiedniości między nazwą, a adresem zmiennej

Zmienne Problem aliasowania (ang. aliasing): niekiedy do tej samej komórki pamięci (w tym samym czasie) można dotrzeć za pomocą dwóch różnych nazw, np. gdy dwa wskaźniki ustawimy na ten sam adres. Przykład (język C) int x, *p, *q; p = &x; q = &x; Unikać (niejasność kodu= przyczyna błędów) p q x

Zmienne Parametr Wartość (r-wartość) (ang. right value) zawartość komórki pamięci związanej z daną zmienną Przykład (język C) int a = 5;

Zmienne Parametr Typ zbiór dopuszczalnych wartości, jakie zmienna może przyjmować Przykład (Język C) char (-128, 127) int (-32768, 32767) (signed by default) (unsigned is optional)

Zmienne Typ dla zmiennych w reprezentacji zmiennopozycyjnej, typ określa też precyzję, z jaką liczby są reprezentowane Przykład (Język C) float (3.4 E-38, 3.4 E+38) 7 cyfr precyzji double (1.7 e-308, 1.7 e+308) 15 cyfr precyzji

Zmienne Typ z typem wiąże się również zbiór operacji dopuszczalnych dla danej zmiennej Przykład (język C) int a, b=1, c=2; float x, y=1,z=2; a = b / c; //wynik: a=0 x = y / z; //wynik: z =0.5

Wiązania Dotyczą różnych bytów i atrybutów, które w pewnym momencie zostają powiązane Byty: zmienna operator podprogram Atrybuty: wartość typ adres

Przykłady wiązań Deklaracja zmiennej powoduje związanie zmiennej z typem int a; Wykonanie instrukcji podstawienia powoduje związanie zmiennej z (nową) wartością a = 2;

Przykłady wiązań Wiązanie może następować w różnych momentach W czasie projektowania języka programowania jego twórca wiąże znak * (gwiazdka) z operacją mnożenia W czasie projektowania kompilatora języka typ int zostaje związany z zakresem liczb całkowitych dostępnym dla danej maszyny (dla której zaprojektowany jest kompilator)

Przykłady wiązań W czasie kompilacji zmienna zostaje związana z zadeklarowanym dla niej typem W czasie ładowania programu do pamięci zmienna statyczna zostaje związana z konkretnym adresem w pamięci W czasie konsolidacji wywołanie funkcji bibliotecznej zostaje związane z kodem tej funkcji W czasie wykonywania programu zmienna lokalna zostaje związana z przydzieloną jej na stosie pamięcią.

Przykłady wiązań Przykład (język C) int x; x = x * 2; Typ zmiennej x jest wiązany (z int) w czasie kompilacji. Typ int jest wiązany z konkretnym zakresem liczb całkowitych w czasie projektowania kompilatora. Znak * jest wiązany z konkretnym działaniem arytmetycznym (dopiero) w czasie kompilacji. (nie wcześniej, gdyż konkretne znaczenie gwiazdki zależy od typu operandów (int (mnożenie całkowitoliczbowe) czy float (mnożenie zmiennopozycyjne)?)) Wewnętrzna reprezentacja liczby 2 jest wiązana z pewnym układem bitów w trakcie projektowania kompilatora Wartość zmiennej x jest wiązana z konkretną liczbą w chwili wykonania podstawienia

Klasy wiązań Wiązania statyczne następują przed wykonaniem programu i nie zmieniają się w trakcie jego działania. następują w praktyce w czasie kompilacji Wiązania dynamiczne następują w trakcie działania programu. zmieniają się w trakcie działania programu.

Wiązanie typu Każda zmienna musi zostać związana z typem przed jej pierwszym użyciem w programie. Praktyczne problemy: Problem 1 Jak określamy typ zmiennej? Problem 2 Kiedy następuje wiązanie? (wiązanie jest statyczne czy dynamiczne?)

Jak określamy typ zmiennej? deklaracja jawna (najczęściej spotykane we współczesnych językach) Przykład (język C) int a; deklaracja niejawna (np. pierwsze użycie zmiennej może stanowić deklarację)

Jak określamy typ zmiennej? konwencja może określać typ język Fortran- pierwsza litera nazwy wyznacza typ zmiennej (chyba że zmienna została zadeklarowana jawnie) język Perl- pierwszy znak nazwy wyznacza typ zmiennej (np. $foo - zmienna skalarna, @foo - lista, %foo - tablica haszująca) wnioskowanie o typie z kontekstu użycia (np. język Haskell)

Kiedy następuje wiązanie? Deklaracje wymuszają wiązanie statyczne. Przy wiązaniach dynamicznych zmienna jest wiązana z typem przy pierwszym podstawieniu pod nią wartości (PHP, JavaScript) Zaleta: duża elastyczność Wady: trzeba dynamicznie sprawdzać typ (koszty) utrudnienie wykrywania błędów (wynikajacych z niezgodności typów)

Koszty dynamicznego wiązania typu Z czego wynikają duże koszty? Zgodność typów musi być sprawdzana dynamicznie (w trakcie wykonywania programu) Efekt: wydłużenie czasu wykonywania programu Z każdą zmienną trzeba przechowywać deskryptor opisujący jej typ Efekt: zwiększenie rozmiaru programu

Koszt dynamicznego wiązania typu Operacje na zmiennej są trudniejsze, gdyż wartości różnych typów mogą wymagać zróżnicowanej ilości pamięci i zróżnicowanych działań (rodzaj działań zależy od typu operandów) W praktyce język z dynamicznymi typami musi być interpretowany Powód: w czasie kompilacji nie wiadomo, co będą zawierały zmienne = nie da się wygenerować odpowiedniego kodu

Wiązanie pamięci Pojęcia podstawowe: Okres życia zmiennej- czas, w którym jest ona związana z konkretnym miejscem w pamięci. Alokacja pamięci- pobranie bloku pamięci odpowiedniej wielkości z puli wolnej pamięci i związanie go ze zmienną. Dealokacja (zwolnienie) pamięci- unicestwienie wiązania bloku pamięci ze zmienną i oddanie go do puli wolnej pamięci. Okres życia zmiennej- czas pomiędzy alokacją, a dealokacją.

Podział zmiennych ze względu na okres życia zmienne statyczne (głównie zmienne globalne) zmienne dynamiczne na stosie (zmienne lokalne) zmienne dynamiczne na stercie, jawne. zmienne dynamiczne na stercie, niejawne

Zmienne statyczne Wiązane z miejscem w pamięci przed rozpoczęciem wykonania programu Wiązanie nie zmienia się w trakcie wykonywania programu. Zaleta: efektywne- bezpośrednie adresowanie. Wada: mało elastyczne, takie zmienne nie mogą być używane do obsługi wywołań rekurencyjnych. Przykłady: zmienne globalne zmienne zadeklarowane jako static (w języku C). Uwaga: deklaracja zmiennej z użyciem static wewnątrz definicji klasy w C++ nie oznacza zmiennej statycznej, a zmienną klasową (wspólną dla całej klasy).

Zmienne statyczne Przykład (Język C) #include <stdio.h> void f(void){ static int x = 0; // zmienna statyczna int y = 0; x++; y++; printf("x: %d\n",x); printf("y: %d\n",y); } int main() { f(); f(); return 0; } Output: x: 1 y: 1 x: 2 y: 1

Zmienne dynamiczne na stosie Wiązane z pamięcią w chwili, gdy wykonanie programu dociera do ich deklaracji. Pamięć przydzielana na stosie (stack). Pamięć zwalniana, gdy kończy się wykonanie bloku zawierającego daną zmienną. Dla typowych zmiennych prostych (całkowite, zmiennopozycyjne) wszystkie atrybuty z wyjątkiem pamięci są wiązane statycznie. Zaleta: Mogą być używane w wywołaniach rekurencyjnych. Wady: Mniejsza efektywność ze względu na pośrednie adresowanie (adres jest wyliczany), narzut związany z alokacją i dealokacją, brak historii (każde wywołanie podprogramu tworzy nową instancję zmiennych). Przykłady: zmienne lokalne w funkcjach (w języku C) i w metodach (w języku C++, Java)

Zmienne dynamiczne na stosie Przykład (język C) #include <stdio.h> unsigned int silnia(unsigned int n){ if(n==0){ return 1; }else{ return n*silnia(n-1); } } int main(){ printf("obliczona silnia: %d\n", silnia(3)); return 0; } Output: obliczona silnia: 6

Zmienne dynamiczne na stercie, jawne Alokowane przez programistę w trakcie wykonania programu za pomocą jawnych poleceń, np. new (język C++, Java) malloc() (język C). Dealokowane jawnie (za pomocą free() (język C), delete (język C++) lub niejawnie poprzez mechanizm odśmiecania (ang. garbage collector) (język Java, C#). Nie mają nazwy; dostępne są poprzez wskaźnik lub referencję. Zalety: mogą być używane do tworzenia dynamicznych struktur danych (np. list wiązanych i drzew). Wady: niska efektywność z powodu pośredniego trybu adresowania i skomplikowanego zarządzania stertą duże ryzyko błędów

Zmienne dynamiczne na stercie, jawne Przykład (język C++) dynamiczne wiązanie pamięci statyczne wiązanie typu int *p; p = new int;... delete p;

Zmienne dynamiczne na stercie, niejawne Alokowane i dealokowane niejawnie w trakcie wykonania programu w chwili wykonania podstawienia. Przykład: napisy i tablice w języku Perl. Zaleta: maksymalna elastyczność Wady: wysoki koszt, związany z dynamicznym przechowywaniem atrybutów trudne wykrywanie błędów.

Sprawdzanie zgodności typów Podejście ogólne: Podprogramy traktujemy jako operatory, których operandami są parametry. Instrukcję przypisania trakujemy jako operację dwuargumentową, której operandami są lewa i prawa strona przypisania. Sprawdzanie zgodności typów = Sprawdzenie czy typy operandów są odpowiednie. Określenie typ zgodny oznacza: typ bezpośrednio dozwolony w danym kontekście typ, który jest dozwolony po zastosowaniu niejawnej konwersji typu (wykonywanej przez kod wygenerowany przez kompilator) Błąd typu to użycie operatora z operandem nieodpowiedniego typu.

Sprawdzanie zgodności typów Przykład niejawnej konwersji typów (język C) float x, y; int j; x = y + j; wartość zmiennej j jest automatycznie zamieniana z typu int na float (kierunek konwersji int float); w związku z tym wykonywane jest dodawanie zmiennopozycyjne;

Sprawdzanie zgodności typów Sprawdzanie zgodności typów jest zwykle takie samo jak wiązanie typów: statyczne wiązanie statyczne sprawdzanie dynamiczne wiązanie dynamiczne sprawdzanie Wyjątek: unie (ang. union) przechowują wartości różnych typów w tym samym miejscu pamięci dlatego sprawdzanie pod względem zgodności typów musi być dynamicznie (w trakcie wykonania programu). Przykład (język C) union LiczbaLubZnak { int calkowita; char znak; double rzeczywista; };

Języki silnie i słabo typowane Język nazywamy silnie typowanym, jeśli błędy typu są w nim zawsze wykrywane. Zaleta: możliwość wykrywania wielu pospolitych błędów. Języki prawie silnie typowane mają możliwość wykonania jawnej konwersji typów (rzutowanie typów) Przykłady: Java, C#, Ada Przykład jawnej konwersji typów (język Java) int a = 5; double b = 13.5; int c = (int)b/a;

Języki silnie i słabo typowane Języki C i C++ nie są silnie typowane (np. można uniknąć sprawdzania typów parametrów) Języki słabo typowane oferują niejawne konwersje typów ukryte przed programistą Przykład niejawnej konwersji typów (język PHP) php > echo "45" + 12; Output: 57

Silne typowanie, a niejawne konwersje Silne typowanie chcemy mieć po to, by wykrywać jak najwięcej błędów. Występowanie w języku niejawnych konwersji osłabia sens silnego typowania. Powód: niejawne konwersje powodują, że np. błędne podstawienia mogą formalnie przestać być błędami typu. Silne typowanie bez konwersji sprzyja niezawodności (kosztem wygody programisty). Przykład: zasady niejawnych konwersji sprawiają, że sprawdzanie zgodności typów w języku Ada jest bardziej skuteczne niż w języku Java, a to z kolei jest bardziej skuteczne niż w języku C++.

Silne typowanie, a przeciążenie Przeciażanie operatorów, funkcji, metod pozwala kompilatorowi/interpretatorowi dobierać operacje w zależności od kontekstu użycia Przykład (Język Python) >>> # dodawanie calkowitoliczbowe >>> 2 + 3 5 >>> # dodawanie zmiennopozycyjne >>> 2.0 + 3.0 5.0 >>> # laczenie napisow >>> "2" + "3" '23' >>> '2' + '3' '23'

Jak zdefiniować zgodność typów? Rodzaje zgodności typów zgodność nazwy zgodność struktury (opisu)

Zgodność nazwy dwie zmienne uznajemy za zgodne co do typu, jeśli zostały zdefiniowane w tej samej deklaracji lub jeśli do ich zadeklarowania użyto tej samej nazwy typu. Zdefiniowanie zgodności typów poprzez zgodność nazwy jest łatwiejsze w implementacji, ale bardzo restrykcyjne, wrażliwe na błędy Przykład zgodności nazwy (Język C) typedef float mile ; typedef float jardy ; Typ mile jest zgodny z typem jardy Przykład zgodności nazwy (Język Ada) type mile is new Float ; type jardy is new Float; Typ mile nie jest zgodny z typem jardy

Zgodność struktury dwie zmienne uznajemy za zgodne co do typu, jeśli mają taką samą strukturę W tym przypadku potrzebne są doprecyzowania Czy struktury struct o takiej samej strukturze, ale innych nazwach pól, są zgodne? Czy tablice o takim samym typie elementów są zgodne, jeśli jedna ma zakres indeksów 0..99, a druga 1..100? Zdefiniowanie zgodności typów poprzez zgodność struktury jest elastyczne, ale trudniejsze w implementacji Aby rozróżnić typy o takiej samej strukturze należy zastosować mechanizm: podtypów typów pochodnych.

Typy pochodne Typ pochodny (ang. derived type) Nowy typ oparty na typie już istniejącym. Dziedziczy wszystkie własności typu bazowego. De facto to kopia typu utworzona pod inną nazwą. Nie jest zgodny z typem bazowym- pozwala to na konstruowanie typów identycznych co do struktury, ale niezgodnych z typem bazowym.

Typy pochodne Przykład (język Ada) Chcemy liczyć jabłka i pomarańcze type Apples is new Integer; type Oranges is new Integer;... No_Of_Apples : Apples; No_Of_Oranges : Oranges; Obydwa typy dziedziczą operacje dodawania po typie Integer: No_Of_Apples := No_Of_Apples + 1; No_Of_Oranges := No_Of_Oranges + 1;

Podtypy Podtyp (ang.subtype) jakiegoś typu to jego podzbiór (w sensie matematycznym) Z założenia jest zgodny z typem bazowym Przykład podtypów (język VHDL) subtype Natural is Integer range 0 to Integer'high; subtype Positive is Integer range 1 to Integer'high;

Zakres widoczności atrybut, np. zmiennej Zakres widoczności to obszar kodu programu (niekoniecznie ciągły), w którym można się do danej zmiennej odwołać (tzn. użyć jej). Zakres widoczności nie wolno mylić z okresem życia (kolejny atrybut) Okres życia to pojęcie związane z czasem (czasem działania programu) Zakres widoczności to pojęcie związane z przestrzenią (obszarem kodu programu)

Lokalność zmiennej Pojęcia związane z zakresem widoczności: Zmienna lokalna (względem danego fragmentu kodu, podprogramu, itp.) to zmienna zadeklarowana w danym bloku, jednostce programu, itp. Zmienna nielokalna (także względem danego fragmentu kodu, podprogramu, itp.) to zmienna widoczna w danej jednostce, ale zadeklarowana gdzie indziej. Zmienna globalna to zmienna widoczna w całym programie (z wyjątkiem przypadku jej przesłonięcia).

Zakres widoczności statyczny (leksykalny) MAIN P1 P2 dynamiczny MAIN P2 P1 W obydwu przypadkach możliwe jest przesłanianie nazw.

Zakres statyczny widoczności Dotyczy m.in. języków kompilowalnych (np. C, C++) i innych np. Java, Ruby. Opiera się na kodzie źródłowym programu (w sensie przestrzennym). W przypadku języków kompilowalnych ustalany jest w czasie kompilacji (szybsze, mniej elastyczne). Zakładamy, że wszystkie zakresy są związane z jednostkami programu i że rozstrzyganie zakresu jest jedyną metodą odwołania się do zmiennych nielokalnych. Uwaga! Nie zawsze jest to obowiązujące Przykład (język C++). Operator zasięgu(::) pozwala na dostęp do niewidocznej zmiennej.

Zakres statyczny Odwoływanie się do zmiennych Napotkawszy odwołanie do zmiennej kompilator musi odnaleźć jej deklarację i określic jej atrybuty. Deklaracji szuka się najpierw w bieżącej jednostce programu. Jeśli tu jej nie ma, szuka się w jednostce ją okalającej (w tzw. poprzedniku statycznym). Jeśli i tu jej nie ma, trzeba szukać w poprzedniku poprzednika itd. (czyli w przodkach statycznych), być może docierając aż do zakresu globalnego czyli do programu głównego. Zmienne mogą się przesłaniać. Jeśli w bliższym przodku statycznym jest zadeklarowana zmienna o takiej samej nazwie, jak w dalszym przodku, to przesłania ona tę dalszą.

Zakres statyczny Dostęp do przesłoniętych zmiennych Język może oferować mechanizmy pozwalające na dostęp do przesłoniętych zmiennych. Przykład (język C++) Operator zasięgu (::) np. ::somevariable

Zakres statyczny Bloki Język może oferować mechanizmy pozwalające na dostęp do przesłoniętych zmiennych. Przykład 1 (języki C i C++) Można zadeklarować zmienną na początku dowolnego bloku wyznaczonego przez nawiasy klamrowe. f() { int a;... }

Zakres statyczny Bloki Przykład 2 (języki C++, Java i C#) Można zadeklarować zmienną w instrukcji pętli for: for(int i = 0; i<n; i++){ a[i] = 0; } Zakresem widoczności dla zmiennych z przykladu 1 oraz 2 jest rozważany blok: od { do }

Zakres statyczny Bloki Tak zadeklarowane zmienne (Przykład 1 oraz 2) są to zmienne dynamiczne alokowane na stosie. Pamięć jest alokowana za każdym razem przy wejściu do bloku, a dealokowana przy wyjściu z niego.

Zakres statyczny Przykład (Język C++) int z =3; // z jest zmienną globalną (zewnętrzną); void f() { float b = 2; /* b jest zm. lokalną (automatyczną) widoczną jedynie w funkcji f */ b = b + z; // b jest tutaj równe 5; } void g() { int z =10; // ta deklaracja przesłoniła z globalne int d = 2; d = d + z; // d jest tutaj równe 12 (2 + 10) d = d + b; /* kompilator w tym miejscu wskaże błąd; b nie jest widoczne w funkcji g.*/ d = z + ::z; /*tutaj d = 13 (10 + 3); operator :: powoduje, że zostanie odczytana globalna zmienna z, która jest przesłonięta przez lokalną zmienną z.*/ }

Zakres statyczny Zagnieżdżone definicje procedur (problem) P0 { } //zakres globalny P1 { P3 { } P4 { /*problem jeżeli P4 potrzebuje } odwołać się do danych z zakresu } P2; jeśli przeniesiemy P4 do P2 { wnętrza P2 nie bedzie możliwe P5 { wywołanie P4 przez P1*/ } }

Zakres dynamiczny Ustalany jest w czasie wykonywania programu. Przykład: język Clojure (poprzez mechanizm wiązań (binding), ale jest wybór (let)). Opiera się na kolejności wywołań podprogramów, a nie na ich rozmieszczeniu przestrzennym. Jako kryterium rozstrzygania o dostępie przyjmujemy bliskość czasową (a nie bliskość przestrzenną).

Zakres dynamiczny Odwoływanie się do zmiennych Przy napotkaniu odwołania do zmiennej kompilator musi odnaleźć jej deklarację i określić jej atrybuty. Deklaracji szuka się najpierw w bieżącym podprogramie (podobnie jak dla zakresu statycznego). Jeśli tu jej nie ma, trzeba szukać w podprogramie, który wywołał bieżący podprogram (w tak zwanym poprzednikiem dynamicznym). Jeśli i tu jej nie ma, trzeba szukać w poprzedniku poprzednika itd. (czyli w przodkach dynamicznych), być może docierając aż do zakresu globalnego czyli do programu głównego. Zmienne mogą się przesłaniać. Jeśli w bliższym przodku dynamicznym jest zadeklarowana zmienna o takiej samej nazwie, jak w dalszym przodku, to przesłania ona tę dalszą.

Zakres dynamiczny Zagnieżdżone definicje procedur (problem) P0() { int x; P1() { int x; P2(); } P2() { Put(x); /*odwołanie do zmiennej x } w wywołaniu Put(x)odnosi się do zmiennej zadeklarowanej w P1 P1(); (P1 jest poprzednikiem dynamicznym dla P2). } Gdyby język stosował zakresy statyczne, to to samo odwołanie odnosiłoby się do zmiennej zadeklarowanej w P0*/

Zakres statyczny vs. zakres dynamiczny 01 const int b = 5; 02 int foo() 03 { 04 int a = b + 5; 05 return a; 06 } 07 08 int bar() 09 { 10 int b = 2; 11 return foo(); 12 } 13 14 int main() 15 { 16 foo(); // returns 10 17 bar(); // returns 10 18 return 0; 19 } 01 const int b = 5; 02 int foo() 03 { 04 int a = b + 5; 05 return a; 06 } 07 08 int bar() 09 { 10 int b = 2; 11 return foo(); 12 } 13 14 int main() 15 { 16 foo(); // returns 10 17 bar(); // returns 7 18 return 0; 19 }

Wady zakresów Zakres statyczny: nadużywanie zmiennych globalnych Zakres dynamiczny: gorsza efektywność (rozstrzyganie zakresu musi być robione dynamicznie) nie da się statycznie sprawdzić zgodności typów dla zmiennych nielokalnych słaba przejrzystość programu słaba czytelność odwołań podprogramy są wykonywane w środowisku wcześniej wywołanych podprogramów, które jeszcze nie zakończyły działania. wniosek: pomiędzy rozpoczęciem a zakończeniem działania podprogramu jego lokalne zmienne są widoczne dla innych podprogramów, niezależnie od ich bliskości przestrzennej.

Zakres widoczności, a okres życia Przypadek 1 (pojęcia bardzo bliskie) Język Java: public void example() { //x,y,z są niewidoczne int x; //x jest widoczna for ( int y = 1 ; y < 10 ; y++ ) { //x,y są widoczne int z; //x,y,z są widoczne } //x jest widoczna } Zmienna jest zadeklarowana w metodzie, która nie wywołuje innych metod. Jej zakres widoczności rozciąga się od deklaracji do końca bloku. Jej okres życia zaczyna się przy wejściu do metody i kończy się w chwili, gdy kończy się wykonanie metody.

Zakres widoczności, a okres życia Przypadek 2 (pojęcia rozbieżne) Język C #include <stdio.h> void foo() { int a = 10; static int sa = 10; a += 5; sa += 5; printf("a = %d, sa = %d\n", a, sa); } int main() { int i; for (i = 0; i < 5; ++i) foo(); } Output: a = 15, sa = 15 a = 15, sa = 20 a = 15, sa = 25 a = 15, sa = 30 a = 15, sa = 35 Zmienna zadeklarowana jako static wewnątrz funkcji ma lokalny zakres widoczności ale globalny okres życia.

Inne problemy związane ze zmiennymi Środowisko odwołań Zbiór wszystkich zmiennych widocznych w danym punkcie programu nazywamy środowiskiem odwołań tego punktu. W języku z zakresami statycznymi środowisko tworzą wszystkie zmienne zadeklarowane lokalnie wraz ze zmiennymi z przodków statycznych, z wyjątkiem zmiennych przesłoniętych. W języku z zakresami dynamicznymi środowisko tworzą wszystkie zmienne zadeklarowane lokalnie wraz ze zmiennymi z aktywnych (aktualnie wykonywanych) podprogramów, z wyjątkiem zmiennych przesłoniętych.

Inne problemy związane ze zmiennymi Stałe Stała nazwana to zmienna, która jest wiązana z wartością tylko raz w chwili wiązania z pamięcią. Przykład (język C) const int x=4; #define x 4; Zalety: polepszenie czytelności kodu i ułatwienie modyfikowania programu. Uwaga! #define nie jest częścią języka programowania (preprocesor vs kompilator)

Inne problemy związane ze zmiennymi Inicjowanie zmiennych Wiązanie zmiennej z wartością w chwili, gdy jest ona wiązana z pamięcią nazywane jest inicjalizacją (podobnie jak w przypadku nazwanej stałej, ale wartość zmiennej może się zmieniać). Jeśli alokacja jest statyczna to inicjalizacja jest jednokrotna. Jeśli alokacja jest dynamiczna to inicjalizacja jest wielkrotna (podczas każdej alokacji). W wielu językach inicjalizacji można dokonać przy deklaracji zmiennej Przykład (języki C, C++, Java, C#) int y=4;

Typ Formalnie to ustalony zbiór dopuszczalnych wartości jakie dana może przyjmować. Typ matematyczny zbiór skończony (z uwagi na ograniczoną wielkość pamięci-python lub zdefiniowany zakres- C++, Java). Wyznacza zbiór operacji dopuszczalnych na danej. Technicznie ustala reprezentację danej w pamięci komputera. W konsekwencji ustala sposób traktowania danej przez kompilator lub interpretator. Oferuje dodatkowe narzędzie abstrakcji (w stosunku do zmiennych).

Typ Aspekty wykorzystania typów: sprawdzanie zgodności typów kompilator lub interpretator może kontrolować czy odpowiednie dane są użyte w odpowiednim kontekście, nie pozwalając na operacje nie zdefiniowane w języku np. Język C Przykład 1 Przykład 2 char ch = 'A'; char ch = "A"; /* błąd */ const char * st = 'A'; /* błąd*/ const char * st = "A";