1 / 60

A D programozási nyelv

A D programozási nyelv. Bevezetés. Amiről ma szó lesz… Miért D? Mert a fejlesztők úgy látták, hogy a C++-on van még mit javítani. Mert a programozók a nyelvnek általában elszigetelt részeit használják csak. Mert a gyakran használt típusok (string, vector) nem a nyelv részei.

thimba
Download Presentation

A D programozási nyelv

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. A D programozási nyelv

  2. Bevezetés • Amiről ma szó lesz… • Miért D? • Mert a fejlesztők úgy látták, hogy a C++-on van még mit javítani. • Mert a programozók a nyelvnek általában elszigetelt részeit használják csak. • Mert a gyakran használt típusok (string, vector) nem a nyelv részei. • Mert a fordítók ma már okosabbak.

  3. A D fő céljai • Gyakran használt funkciókat a nyelv részévé tenni. • Több paradigma támogatása • Egyszerűsítés, hogy könnyebb legyen • Hasonlítson a C++-hoz • Könnyű legyen fordítóprogramokat írni a nyelvhez • Contract-ok és unit-tesztek • Dokumentálás könnyítése

  4. Megtartott funkciók • A kinézet • Procedurális, objektum-orientált és template-(meta)programozás támogatása • Kivételek (try-catch-finally) • Futásidejű típusazonosítás • Operátor túlterhelés • RAII • „down and dirty programming” ~ „architektúraközli programozás”

  5. Elhagyott funkciók • Kompatibilitás C/C++-szal • Link kompatibilitás C++-szal • C preprocesszor • Többszörös öröklődés • Névterek • Forward deklaráció • Includefiles(nem kell mindig újraparszolni az egész include-ot, hanem be tudja tölteni a kész szimbólumtáblát) • Nem-virtuális tagfüggvények • 16-bites kompatibilitás

  6. Fő tulajdonságok

  7. Utasítások, vezérlési szerkezetek

  8. Kifejezések • C/C++ -hoz hasonló • Értékadó operátor kifejezés • Kifejezések részkifejezéseinek kiértékelése általában tetszőleges sorrendben történhet • Logikai kiefejezések balról jobbra, rövidre zárva • Feltételes kifejezések C/C++ -hoz hasonlóan • (log kif) ? expression : expression; • Cast-olás: cast (type) expression

  9. Utasítások • If, for, while, switch: C/C++ -hoz hasonló • Switch –ben string-et is használhatunk • Foreach utasítás

  10. OO

  11. Objektumorientáltság • Nincs többszörös öröklődés • Interface-ek bevezetése • Minden osztály az Object-ből származik • Minden függvény virtuális (kivéve static/final) • Vannak zárt osztályok • Az osztály referencia

  12. Konstruktorok • Minden adattag automatikusan inicializálódik • A már megírt konstruktor használható • Példányosítás a new kulcsszóval • A a = new A(3); class A { this(int y) { } } class B : A { int j; this() { ... super(3); // call base constructor A.this(3) ... } }

  13. Destruktorok • GC hívja meg (általában)

  14. Beágyazott osztályok classOuter { classInner { } staticclassSInner { } } voidfunc() { classNested { } Outer o = newOuter; // Ok Outer.Inner oi = newOuter.Inner; // Error, no 'this' forOuter Outer.SInneros = newOuter.SInner; // Ok Nested n = newNested; // Ok }

  15. Operátor túlterhelés • Operátor, opfunc • Op a  a.opfunc();

  16. Bináris operátor túlterhelés • a op b  a.opfunc(b); • VAGY  b.opfunc_r(a);

  17. Resource Acquisition Is Initialization Kezdeti értékadás == Az erőforrás megszerzése A C++ módszer erőforrások kezelésére GC szép és jó, de használhatatlanná teszi az RAII-t RAII

  18. Erőforrás-kezelés JAVA-ban

  19. Erőforrás-kezelés C#-ben • IDisposeable interfész, Dispose() függvény

  20. Erőforrás-kezelés C#-ben

  21. És akkor RAII, C++-ban:

  22. És akkor RAII, C++-ban:

  23. Végül: RAII D-ben • Garbage Collection van • Objektumok a heap-en jönnek létre, nincs explicit élettartamuk • Try/finally –t is használhatunk erőforrás kezelésre • RAII támogatása: scope attribútum

  24. Végül: RAII D-ben

  25. Scope Guard statements • scope(exit)NonEmptyOrScopeBlockStatement • scope(success)NonEmptyOrScopeBlockStatement • scope(failure)NonEmptyOrScopeBlockStatement

  26. Függvények

  27. Általában • Bevezettek több fajta függvényt • Függvényeket lehet egymásba ágyazni • Függvényekre bevezették az invariáns fogalmát • Delegátok • Inline függvények

  28. Függvényliterálok int function(char c) fp; void test() { static intfoo(char c) { return 6; } fp = &foo; } int function(char c) fp; void test() { fp = function int(char c) { return 6;} ; }

  29. Függvényliterálok folytatás int abc(int delegate(long i)); void test() { int b = 3; int foo(long c) { return 6 + b; } abc(&foo); } int abc(int delegate(long i)); void test() { int b = 3; abc( delegate int(long c) { return 6 + b; } ); } // no referencetoreturnvalue intabc(int delegate(long i)); void test() { int b = 3; abc( (long c) { return 6 + b; } ); }

  30. Beágyazott függvnyek int bar(int a) { int foo(int b) { int abc() { return 1; } return b + abc(); } return foo(a); } void test() { int i = bar(3); // i is assigned 4 }

  31. Beágyazott függvények – tulajdonságok • A beágyazott függvények csak a scope-jukban érhetők el. • A beágyazott függvények elérik a beágyazó változóit és módosíthatják is őket. • Beágyazott függvény lehet member-ben is, de az osztály nem statikus adattagjait nem éri el • Buktató: beágyazott függvények nem hivatkozhatnak egymásra (követező dia)

  32. Buktató void test() { voidfoo() { bar(); } // error, barnotdefined void bar() { foo(); } // ok } //megoldás void test() { voiddelegate() fp; voidfoo() { fp(); } void bar() { foo(); } fp = &bar; }

  33. Property függvények struct S { int m_x; @property { int x() { return m_x; } int x(int newx) { return m_x = newx; } } } voidfoo() { S s; s.x = 3; // callss.x(int) bar(s.x); // callsbar(s.x()) }

  34. Pure függvények • Garantálja, hogy a minden futása ugyanolyan eredménnyel jár • Paraméterei • Vagy inmutable típusok • Vagy implicit azzá konvertálhatók

  35. Ref függvények • Az alapértelmezett függvényvisszatérési érték jobbérték. • Ref kulcsszóval lehet balértékként visszaadni értéket ref int foo() { auto p = new int; return *p; } ... foo() = 3; // reference returns can be lvalues

  36. Auto függvények • A visszatérési értéküket automatikusan ki tudja következtetni auto foo(int i) { return i + 3; // return type is inferred to be int }

  37. Paraméterek • A paraméterek lehetnek • in, • out, • ref, • Stb: (lazy, final, const, immutable, scope) • in = const scope • out : Mindig inicializálódik! • Minősítő nélkül mutable másolat lesz a paraméter értéke

  38. Variadic függvények • C-stílusú foo(3, 4, 5); // first variadic argument is 5 int foo(int x, int y, ...) { int z; z = *cast(int*)_argptr; // z is set to 5 } • Típusinfóval ellátott • Típusbiztos

  39. Típusinfóval import std.stdio; class Foo { int x = 3; } class Bar { long y = 4; } void printargs(int x, ...) { writefln("%d arguments", _arguments.length); for (int i = 0; i < _arguments.length; i++) { _arguments[i].print(); if (_arguments[i] == typeid(int)) { int j = *cast(int *)_argptr; _argptr += int.sizeof; writefln("\t%d", j); } else if (_arguments[i] == typeid(long)) { … } else if (_arguments[i] == typeid(Bar)) { Bar b = *cast(Bar*)_argptr; _argptr += Bar.sizeof; writefln("\t%X", b); } else assert(0); } } void main() { Foo f = new Foo(); Bar b = new Bar(); writefln("%X", f); printargs(1, 2, 3L, 4.5, f, b); }

  40. Típusbiztos int test() { return sum(1, 2, 3) + sum(); // returns 6+0 } int func() { int[3] ii = [4, 5, 6]; return sum(ii); // returns 15 } int sum(int[] ar ...) { int s; foreach (int x; ar) s += x; return s; }

  41. Contract-ok

  42. Contract-ok long square_root(long x) in { assert(x >= 0); } out (result) { assert((result * result) <= x && (result+1) * (result+1) >= x); } body { return cast(long)std.math.sqrt(cast(real)x); }

  43. Miért jó ez? • Egységes kinézet a contract-oknak • Tool support • A fordító jobb kódot tud generálni ezzel az információval • Könnyebb a kezelése és kikényszerítése • Az öröklődés kezelése …

  44. Öröklődés • Member függvények esetén öröklődéskor a következő szabályok érvényesek • in contractok diszjunkciójának • out contractok konjunkciójának • kell teljesülni

  45. Invariánsok • Lefut • Konstruktor után • Destruktor előtt • Publikus member előtt és után • Hiba esetén AssertError-t dob • Csak egy invariánsa lehet egy osztálynak • Release-re fordításnál az invariáns kód nem fordul le class Date { int day; int hour; invariant() { assert(1 <= day && day <= 31); assert(0 <= hour && hour < 24); } }

  46. Unit tesztek • Nyelvi támogatásuk van • Osztályok speciális tagfüggvényei, osztályonként csak egy • Statikus inicializálás után, main előtt futnak le • A fordító a release fordításnál kihagyja a unit tesztek fordítását

  47. Unit tesztek

  48. Tömbök

  49. Tömbök típusai • Pointerek • int* p; • Statikus tömbök • int[3] s; • Dinamikus tömbök • int[] s;

  50. Deklaráció int[] a; // dynamic array of ints int[4][3] b; // array of 3 arrays of 4 ints each int[][5] c; // array of 5 dynamic arrays of ints int*[]*[3] d; // array of 3 pointers to dynamic arrays of pointers to ints int[]* e; // pointer to dynamic array of ints

More Related