Ako Kód: Pascal

Link: https://www.allegro.com/papers/htpp.html

Stan Sieler

Allegro Consultants, Inc.

[email protected]

0. Úvod

Táto kniha sa zaoberá, ako napísať kvalitný Pascal kód. Dôraz sa kladie na kódovanie aspekty písania Pascal kód.

Vzorový program: roman.p.txt, program na prevod Rímske číslice do arabské číslice.

Vzorky zlé kód: rezania, skutočnom reálnom svete kus zlé kód.

Ako žiadať programovanie pomôcť: tu.

Poznámka: tento materiál používa Pascal/iX, Pascal na HP 3000 počítač, ale takmer všetky body sa vzťahujú na akýkoľvek variant Pascal, a najviac sa vzťahujú na iných programovacích jazykoch rovnako.

Chcem diskusie v tejto papier na pokrytie štyroch P o programovania: filozofia, výkon, problémy, a prenosnosť. Ja som za snaží rozdeliť tento papier do štyroch kapitol, jeden pre každú z P’, ale uvedomil si, že pre mnohých tém, ktoré by som dať do jednej kapitoly, rovnako dobré argumenty by mohol byť zvýšený na uvedenie do inej. Takže, namiesto toho, že jedna kapitola za s P I usporiadali tento papier do kapitol: Štýl, Kódovanie, Možnosti, Problémy s Výkonom, a Prenosnosť.

V každej kapitole, 4 P sa používa ako princípmi, ktoré sú základom súbor usmernení. Tieto navrhované pravidlá by nemali byť vnímané ako keď to boli oni, 10 (alebo %12 alebo $A) Prikázaní. Sú moje pravidlá, tie, ktoré som použil (v rôznych formách pre rôzne jazyky), v písaní z viac ako dvoch miliónov riadkov kódu. Usmernenia by mali rásť, ako urobiť ľudí. Môžem sa pozrieť na programy, ktoré som napísal v roku 1970 a vidieť zmeny v štýle v uplynulých rokoch. Napriek tomu, že sa zmení celkový vzhľad zostal rovnaký.

Hlavným cieľom tejto knihy je povzbudiť čitateľa premýšľať o rôznych aspektoch štýl a forma ich vlastné kódovanie usmernenia. To je dôležité opory na písanie kvalitné programy … v Pascale alebo akéhokoľvek jazyka.

Napísal som viac než milión lines high-level jazyku zdrojového kódu od roku 1970. To, samozrejme, obsahuje nejaké prázdne riadky, komentár čiary a línie, ktoré sú klonovanie z iných súborov. Napriek tomu, v tejto súvislosti ma naučila, že “vzhľad” (alebo vzhľad) program je kriticky dôležité pre pochopenie toho, čo kód robí.

Obsah

Hlavné časti sú:

  • 0. Úvod
    • 0.1 Hodiť-preč kód
  • 1. Štýl
    • 1.1 Mená : Základy
    • 1.2 Mená : Ďalšie Údaje
    • 1.3 Objednávanie Zdroj
    • 1.4 Spustiteľný Kód
  • 2. Kódovanie Rozhodnutia
  • 3. Problémy s výkonom
  • 4. Prenosnosť
  • 5. Zhrnutie

0.1 Hodiť-preč kód

Usmernenia:

#1-1. Nie je tam žiadna taká vec ako throwaway kód. Preto, vaše pokyny sa vzťahujú na všetko, čo píšete. Najmä “throwaway” alebo “one-shot” programy.

Komentár:

#1-1. Všimol som si, že som takmer vždy znovu použiť moje údajne throwaway alebo jednorazové programy. A ak som rezať zákruty na používanie moje pokyny vždy som musieť platiť za to neskôr.

1. Štýl

Štýl, alebo nedostatočné, môže výrazne ovplyvniť kvalitu programu. Kvalita kód musí byť napísaný tak, že je to správne, efektívne a ľahko udržiavateľné. Výber, a sledovanie, určitý štýl môže zvýšiť pravdepodobnosť, že každá z týchto troch cieľov, ktoré sa dosiahli. Táto časť sa bude najprv diskutovať o premenné a potom zvyšok programu.

1.1 Mená : Základy

Jedným z kľúčov k úspešnému program je správny výber mien.

Úspech Pascal program spočíva v dobré pochopenie údajov program manipuluje. Toto chápanie sa odráža vo výbere dátové štruktúry a premenné, ktoré používa program.

V celom tomto dokumente sa výraz “mená”, keď sa používa bez qualifier, sa odkazuje na názvy premenných, konštánt, typov, procedúry a funkcie.

Usmernenia:

#1-11. Používať podstatné mená premenných, konštánt, typov; používať sloveso frázy pre procedúr a funkcií.

#1-12. Typy by mali zvyčajne majú “_type” na konci svoje meno.

#1-13. Mená by mali byť úplne malé, podčiarkovník (“_”) oddeľovanie slov (napr.: card_count).

Komentár:

#1-11. Nasledujúce jeden riadok príklad by mala stačiť ukázať význam tohto usmernenia:

 if card_count = 52 then

Je “card_count” celočíselná premenná alebo funkcia? Rozdiel je dôležité pre pochopenie program. Len usmernenie čitateľ môže mať, je možné jeho/jej pochopenie angličtine. (O písaní veľkých písmen, pravidlo by to stačilo!)

Je dôležité si uvedomiť, že iní ľudia budú čítať kód jedného dňa. (“Iných” ľudí zahŕňa si deň po napísaní kód!) Budú potrebovať “ukazovatele”, aby im pomohol správne interpretovať kód čítajú.

Podľa usmernenia #1-11, “card_count” je variabilný. Ak to mal byť funkcie, potom jeho meno by bolo niečo ako “count_the_cards”.

#1-12. Niektorí programátori, napíš pred “t_”, “typ_”, alebo “type_”. Iní append “_t”, “_typ”, alebo “_type”. Niekoľko pomýlených duše boli tak zamilovaný myšlienka, že oni, napíš pred “t_” a pripojiť “_type” na každý druh.

Výhodou pridávanie, namiesto prepending, je, že premenné vzťahujúce sa na rovnakú vec bude triediť spolu, v abecedný zoznam premenných.

Základná myšlienka je jasne odlíšiť mená používateľom definované typy z premenných a postupy (alebo funkcií).

#1-13. Toto usmernenie sa odráža skutočnosť, že sme angličtinou. Keby Sme boli nemčiny, naše Programy by pravdepodobne používať veľké Písmená na Začiatku každej Premennej. Všimnite si, ako je oveľa ťažšie prečítať to je?

Vidím tri dôvody, pre kapitalizácia prvé písmeno (alebo všetky) niektoré typy mien. Nikto sa oplatí:

  • ste si vybral zlé mien pre vaše premenných, a myslím si, že kapitalizáciu bude kompenzovať. …to nebude.
  • ste si nie ste istý, kompilátor vie, že meno premennej, ak nie je aktivované v danom štýle.
    Prekvapenie: kompilátor je múdrejší ako ty!
  • (hlavne pre C programátorov), v ktorej má schopnosť dôkladne zmiasť čitateľa tým, že dve rôzne premenné, ktoré sa líšia iba v prípade ich mená (napr.: int foo; char FOO).
    …viac čestné cesty na bezpečnosť práce existovať.

Pri písaní C, robím veľké moje makro mená (“#define FAIL(s)…”),  pretože to je ohromne najpopulárnejší spôsob, ako to robí. Stále to nie je bez pang ľútosti. Stratíte niektoré flexibilitu, keď budete postupovať podľa tohto dohovoru.

Teraz, keď som zmena jednoduchá premenná ako “lines_cached” byť define (možno preto, že som teraz sledovať počet linky na cache na niečo základ), nemôžem povedať len: #define lines_cached cached_lines_count [clc_simple] musím povedať #define LINES_CACHED cached_lines_count [clc_simple] *a* urobiť globálnu zmenu “lines_cached” “LINES_CACHED“.

V all-dolnom prípade dňoch môjho C programovanie, by som mohol prepnúť niečo z toho, jednoduchá premenná, ak je viac komplexné bez pozorovateľnej zmeny v zvyšok kódu. OTOH, teraz, keď vidím LINES_CACHED, je to pripomenutie, že je to trochu zložitejšie pojem, ako “lines_cached“.

1.2 Mená : Ďalšie Údaje

Mená pre typy by mali byť opisný, a malo by byť jasne odlíšiteľné typy tak, aby sa vyniknúť, keď sa používa typ nátlaku alebo “sizeof” výrazy.

Usmernenia:

#1-21. Generické typy, ktoré sú balené polia char by mal byť pomenovaný ako “pac” s počet znakov.

type
      pac8        = packed array [1..8] of char;
      pac80       = packed array [1..80] of char;

#1-22. Typy, ktoré sú polia by mali mať “array” v názve. (Výnimka: pac## názvy typu (pozri #1-21).)

#1-23. Typy, ktoré sú ukazovateľmi by mali mať “ptr” v názve. Typy, ktoré sú dlhé ukazovateľov (64 bitov) by mali mať “lptr” v názve. (V Pascale/iX, bežné ukazovatele sú 32-bitov široký…”long” ukazovateľ je 64-bitový ukazovateľ, ktorý si miesto kdekoľvek v pamäti.)

#1-24. Záznamy by mali mať oblasti mená s predponou, ktorá odráža záznam sú súčasťou.

#1-25. Jednoduché druhy by nemali zvyčajne odrážajú ich “size”.

#1-26. Snažte sa vyhnúť použitie “true” a “false” pre funkčné výsledky. Použiť typu, ako je “good_failed_type” miesto.

Komentár:

#1-21. Pascal jazyk má osobitné pravidlá pre premenné, ktoré sú balené polia char s dolná hranica 1. Tieto osobitné pravidlá, ktoré boli pridané v snahe, aby sa štandardné Pascal použiteľné pre text manipulácie. Výsledkom je, že väčšina implementácií Pascal pozrite si časť “PAC” ako variabilný (alebo zadajte), ktorý je zabalený pole char, pričom dolná hranica 1. Preto je vhodné, aby zodpovedali tejto štandardizácia v našich vlastných typov.

Upozorňujeme, že toto usmernenie povedal generické typy. Keď som sa použiť TurboIMAGE (a databázový systém na HP 3000), a chcete vytvoriť typ, ktorý zodpovedá položky IMAGE, budem sa snažiť dať zadajte názov, ktorý sa podobá na položku meno:

{IMAGE items:     }
         {   cust_name x20;}

   type
      cust_name_type          = packed array [1..20] of char;

Vo vyššie uvedenom príklade som použil “20” v typ vyhlásenie len preto, že bol priamo zjavnú hodnotu (vzhľadom na komentár o OBRÁZKU položky). Nikdy by som používať konštanty “20” neskôr v programe. Ak som potreboval pozrite si časť “20”, by som použiť buď Pascal/iX postaviť “sizeof (cust_name_type)” alebo by som pridať “const cust_name_len = 20” a použitia, ktoré konštanta, ak sa má vyhlásiť záznam.

#1-24. Toto usmernenie je polí záznamu okamžite identifikovateľný, keď sú používané v “with” a strát. Príklad:

zlé:

type
      hpe_status  = record  {name matches MPE/iX's usage}
         info : shortint;
         subsys : shortint;
         end;
      hpe_status_ptr_type = ^ hpe_status;
      ...
   var
      hs_status_ptr : hpe_status_ptr_type;
   ...
   with hs_status_ptr^ do
      begin
      info := my_info;
      subsys := my_subsys;
      end;

dobré:

type
      hpe_status              = record       {name matches MPE/iX's usage}
         hs_info              : shortint;
         hs_subsys            : shortint;
         end;

   ...
   with hs_status_ptr^ do
      begin
      hs_info := my_info;
      hs_subsys := my_subsys;
      end;

V zlý príklad, čitateľ, ktorý je známy kód nebude vedieť, že ukazovateľ je polí sa zmeniť. V dobrý príklad, to je zrejmé.

#1-25. V SPL (ALGOL-ako programovací jazyk), je celkom bežné použitie prípony alebo predpony na označenie “type” premennej. (Príklad: dvojité ktr by). S Pascal obmedzenia na zodpovedajúce typy toto je oveľa menej potrebné.

#1-26. “true” a “false” znamená niečo do seba. Príklady:

zlé:

function open_files : boolean;
      ...
      open_files := false;
   ...
   if open_files then
      ...

dobré:

type
      good_failed_type        = (failed, good);

   function open_files : good_failed_type;
      ...
      open_files := good;
   ...
   if open_files = failed then
      ...

V zlý príklad, čitateľ nemá ani poňatia, či sú alebo nie “open_files” vracia hodnotu true, je dobré alebo zlé.

Toto usmernenie je ešte dôležitejšie pri programovaní v multi-jazykové prostredie, pretože v rôznych jazykoch (a iných operačných systémoch) majú zvláštne predstavy o tom, či je “0” (alebo “false”) je dobré alebo zlé.

V mojom C programovanie, používam:

#ifdef GOOD
   #undef GOOD
   #endif

   #ifdef FAILED
   #undef FAILED
   #endif

   #define GOOD 1
   #define FAILED 0

“Undefs” sú tam preto, s neskutočne zlé rozhodovanie, niekto sa podieľajú na BSD alebo Mac rozvoj rozhodol, že súbor /usr/include/protocols/talkd.h, by mali mať makro nazýva FAILED, ktorý má hodnotu 2. (Alebo, na HP-UX, súbor /usr/include/sio/scsi_meta.hGOOD 0, a súbor /usr/include/sys/netio.hFAILED 3.) (Iné zlé exampled GOOD a FAILED neexistuje!)

Súbory poskytnuté OS dodávateľa by NIKDY kooptovať “known” slová ako send, getput, FAILED, alebo free. Takéto slová sú jednoducho príliš všeobecný mať zmysel sám o sebe. Bohužiaľ, sme, ste uviazol s mnohými také slová, ktoré sa už používajú.

1.3 Objednávanie Zdroj

Objednávanie zdrojový kód môže dramaticky ovplyvniť čitateľnosť programu. Objednávanie usmernenia spadajú do troch oblastí: typy & konštanty, premenné a procedúry & funkcie.

(“include files” sú ťažšie kategorizovať … niekedy sa musieť prísť prvý, niekedy musia byť po všetky typy/premenné.)

Usmernenia:

#1-31. Jednoduché konštanty by mal byť kladený na začiatku vyhlásenie oblasti, nasleduje typy, štruktúrované konštanty, a potom premennými. V rámci každej skupiny, identifikátory by mali byť usporiadané v nejakom poradí. Ak nie je iné, aby sa prezentuje, abecedné poradie by mali byť použité. Príklad:

const
      max_queues              = 10;

   type
      aardvark_quantity_type  = 0..9;
      queue_name_type         = packed array [1..8] of char;
      queue_names_type        = array [1..max_queues] of queue_name_type;
      zoo_fed_arrdvarks_type  = array [aardvark_quantity_type] of integer;

#1-32. Najviac jednu inštanciu programu “type”, a “var” je potrebné, a až na dva prípady “const” (jeden pre jednoduché konštanty, a jeden pre štruktúrované konštanty).

#1-33. Identifikátory vo vyhlásení oblasti (konštánt, typov, premenných) by mali byť vyhlásené za jedno na riadok, v niektorých objednávky. Abecedné poradie je predvolené. Ak iný objednávanie je používaný, mala by byť vysvetlené s komentárom.

#1-34. Identifikátory vo vyhlásení, ktoré oblasti by mali byť zapísané tak, že “=” znaky sú zladené pre konštanty a typy, a to “:” znaky sú zladené pre premenné a polia, záznamy.

#1-35. Typy záznamov, ktoré obsahujú vnorené záznamy by nikdy byť deklarované ako “anonymné typy”. Príklady zlé a dobré praktiky sú:
zlé:

type payment_record_type = record
         pay_date : date_type;
         pay_time : time_type;
         pay_style : (paid_cash, paid_check, paid_charge);
         end;

dobré:

type
      payment_style_type      = (paid_cash, paid_check, paid_charge);

      payment_record_type     = record
         pay_date             : date_type;
         pay_time             : time_type;
         pay_style            : payment_style_type;
         end;

#1-36. “Crunched” záznamy by sa mali vyhnúť, ak potrebujete pre pevné balenie polia prepíše výkon straty, ktoré spôsobujú.

Pascal/iX podporuje “crunched záznam”, predĺženie nad rámec jednoduchého “balené záznam”. V crunched záznam, tam sú *č* nevyužité bity. Ak ste vyhlásiť crunched záznam s 1 bitové pole, po ktorom nasledovala 8 bitové pole, po ktorom nasleduje 1 bitové pole, potom celý záznam bude zaberať 10 bitov, a 8-bitové pole bude vyžadovať extra kód load/store.

#1-37. Veľké vonkajšie blok premenných (> 256 bajtov) by mali byť vyhlásené v minulom, aj keď to porušuje usmernenie #1-33. (Podobne, veľké lokálne premenné by mali byť vyhlásené za prvé.) (Poznámka: toto je Pascal/iX výkon tip … inými kompilátormi na iné stroje pravdepodobne robiť veci inak!)

#1-38. Procedúry a funkcie sú navzájom zmiešané (t. j.: nie samostatné postupy z funkcie).

#1-39. Procedúry (funkcie) by mala byť vyhlásená v nejakom poradí (abecedné je predvolené nastavenie).

#1-40. Viac ako jednej úrovne vnorenia postup je potrebné sa vyhnúť.

#1-41. Intrinsics by mali byť deklarované raz, na vonkajšej úrovni, po všetkých konštánt, typov, premenných, a skôr, než akékoľvek “external”, “forward”, alebo skutočných postupov. (“intrinsic” je odkaz na druh vopred zostavené “externé” postup vyhlásenie, podporovaná väčšina jazykov na HP 3000.)

#1-42. Intrinsics by mali byť v abecedné poradie, usporiadané podľa vnútorných súbory. Príklad:

Function ascii    : shortint;  intrinsic;
   Function binary   : shortint;  intrinsic;
   Procedure quit;                intrinsic;

Vo vyššie uvedenom príklade, dva priestory boli uvedené po slove “Funkciu”, tak, aby všetky názvy intrinsics by sa mali zjednotiť, bez ohľadu na to, či boli funkcie alebo procedúry. Je poľutovaniahodné, že Pascal robí nám dokázať, zostavovateľ, že vieme, funkčný typ každý vnútorných.

Poznámka: veľké písmená “P” a “F” v príklade vyššie. Toto je jedna inštancia veľmi užitočné kódovanie disciplína, ktorá je vysvetlená v usmernení #1-45 nižšie.

#1-43. Všetky procedúry a funkcie by mali byť vyhlásené za “vpred” prehlásenia, ktoré sú v abecedné poradie.

#1-44. Typy, ktoré sú “výplne” by mali byť deklarované ako “celé číslo” alebo “byte” (kde “byte” je deklarovaná ako 0..255) a nie ako “char” pre ich základne typy.

#1-45. “forward”, “external”, a “intrinsic” postup (a funkcia) vyhlásenia by mali zarábať prvé písmeno “Procedure” a “Function”.

V mojom C programovanie, mám jeden master patrí súbor ("stddefs.h", ktorý sa nastaví príznaky vhodné pre aktuálny operačný systém (napr., #define HAVE_STRTOLL 1 ak platformy funkcia strtoll), nasleduje OS/dodávateľa za predpokladu, obsahuje (napr., stdlib.h, po ktorom nasleduje moje ďalšie zahŕňa (napr., "sstypes.h",), potom všetky moje globálne typy, výpočty, premenné, definuje kódu, fragmenty, ‘vpred’ funkcia vyhlásenia, potom všetky svoje funkcie. Komentár:

#1-34. Som vo všeobecnosti zarovnajte “=” pre druhy a consts v stĺpci 31 “:” v oblastiach, v rámci druhu aj v stĺpci 31, a “:” pre premenné v stĺpci 19. Ak premenné majú dostatočne dlhé mená, budem často jednoducho zarovnať “:” v stĺpci 31. Som použiť túto zarovnanie “:” používaný v parametri vyhlásenia, ako to, že meno premennej sa začína v stĺpci ??:

procedure parse_gribbitz (
                  a_token     : str80;
              var status      : boolean;
           anyvar stuff       : char)
         option default_parms (
                  stuff       := nil);

Vo vyššie uvedenom príklade, na vedomie, že parameter mená sú v súlade. (Samozrejme, to nie je vždy možné, najmä ak parameter má $zarovnanie$ informácie uvedené.) (Poznámka: “anyvar” je vidieť opäť v 2-9 nižšie)

#1-35. Premenné (a polia záznamov), ktoré sú anonymné typy nikdy nemôže byť schválený odkaz (ako “var” parametre) na bežné postupy. Skutočne anonymné záznamy zvyčajne nemôže byť schválený hodnoty do postupy.

#1-36. Prístup oblasti “crunched” záznamy môže trvať až tri krát počet inštrukcií, ktoré by boli potrebné, ak bol záznam nie crunched. Zvážte nasledujúce dva typy:

type
      bad_type                = crunched record
         bad_misc             : shortint;    {Bytes 0, 1}
         bad_status           : integer;     {Bytes 2, 3, 4, 5}
         end;  {Total size: 6 bytes}

      good_type               = record
         good_misc            : shortint;    {Bytes 0, 1}
         good_status          : integer;     {Bytes 4, 5, 6, 7}
         end;  {Total size: 8 bytes}

Keď “bad_status” pole je prístupné, Pascal/iX vydáva tri pokyny (LDH, LDH, a ZAMEDZENIE spustenia údajov). Keď “good_status” pole je prístupné, Pascal/iX emituje jednej inštrukcie (LDW).

#1-37. Pascal/iX možné efektívne prístup iba prvý 8,192 bajtov globálne alebo *posledná* 8,192 bajtov lokálne premenné. Pascal/iX prideľuje premenných v (asi) prvý-vidieť, prvý-pridelené spôsobom. Teda, pre globálne premenné, uvedenie malé prvý a tie veľké druhý má tendenciu byť efektívnejšie. Pre lokálne premenné, uvedenie tie veľké prvý, a malé druhý má tendenciu byť efektívnejšie.

Pretože Pascal/iX prideľuje vonkajšie bloku (“global”) premenných v opačnom poradí ako lokálne premenné, pravidlo dodržiavať, je:

  • Vo vonkajšom blok, deklarovať svoje malé premenných prvý, a váš veľký premenných, druhý;
  • V procedúry/funkcie, vyhlasujú svoj veľký premenných prvý, a malé premenné na druhom mieste.

Zvážte nasledujúce príklady:

zlé:

 var                                 {outer-block variables}
      big_array   : array [0..9999] of integer;  {40,000 bytes}
      ktr : integer;
   ...
   procedure foo;
      var
         ktr2     : integer;
         big_array_2 : array [0..9999] of integer; {40K bytes}

dobré:

var                                 {outer-block variables}
            {small variables...}
      ktr         : integer;

            {big variables...}
      big_array   : array [0..9999] of integer;
   ...
   procedure foo;
      var
               {big variables...}
         big_array_2 : array [0..9999] of integer; {40K bytes}

               {small variables...}
         ktr2     : integer;

V zlý príklad, Pascal/iX budú používať dva pokyny na prístup k “ktr” a “ktr2”. V dobrý príklad, Pascal/iX bude používať jednotný pokyn na prístup “ktr” a “ktr2”.

#1-38. Pascal diferenciácia funkcie verzus postupov je nešťastné, v najlepšom. Nemali by sme podporovať jazyk dizajnéri nekonečna túto chybu.

#1-39. Pascal/iX je “$lokalita” vyhlásenie môže byť použitý povedať, linker skupiny uvedených postupov spolu bez ohľadu na ich poradie v zdrojovom kóde.

#1-40. Pascal umožňuje postupy byť deklarované v rámci postupy, ktoré sú deklarované v rámci postupy, ktoré sú…

Vnorené postupy zaplatiť run-time výkonu trestu, keď majú prístup premenných, globálne im, že sú lokálne na okolité postupy.

Postupy vnorené viac ako celkom dve hlboké (t. j.: “vonkajšej úrovni” postup a jedného vnútorného poriadku) zvyčajne znamená, že iný dizajn problémy existujú.

Niektoré ladiace nástroje majú ťažkosti nastavenie zarážky na vnorených postupy.

#1-43. Túto prácu navyše, často sa oplatí aj pri písaní “modul”, ktorý bude prepojený s inými programami. Často som sa dať všetky svoje “vpred” vyhlásenia do súboru, a potom použite nasledujúci QEDIT príkazy na generovanie “externé” vyhlásenia súbor pre ostatné moduly na $patrí:

t myfile.forward
   c "forward"(S)"external"@
   k myfile.external

(QEDIT je široko používaný editor na HP 3000.)

#1-44. Debug/iX Formát Virtuálne príkaz (FV) bude produkovať oveľa viac čitateľné výstup pre náhodných dát pri základnej typ je číselné namiesto znaku. (Debug/iX je ladiaci nástroj zviazané s MPE/iX na HP 3000.)

#1-45. S týmto usmernením, a priradený jeden v ďalšej časti, QEDIT príkazu ako:

l "procedure" (s)

zobrazí prvý riadok každého postup vyhlásenie. Všimnite si, že len skutočné vyhlásenie bude uvedené, nie “forward” alebo “external” vyhlásenia, pretože by boli deklarované s veľkým “P” v “Poriadku”.

Poznámka: nie povedz editor automaticky upshift všetky texty hľadáte (napr.: Nastavenie Okna (HORE) v QEDIT), ako to bude v rozpore s účelom tohto usmernenia.

1.4 Spustiteľný Kód

Táto časť sa zaoberá štýly, kódovanie na spustiteľný kód časť Pascal program.

Usmernenia:

#1-50. Všetky kód by mal byť malými písmenami.

#1-51. Pripomienky by mali byť v angličtine, a mali by byť v zmiešaných prípade, ako je prax v anglickom jazyku.

#1-52. Komentáre by sa mali objaviť v jednom z dvoch štýlov, v závislosti na ich veľkosti:

  • zarovnané na vybraný stĺpec (vpravo kód (tak oko dokáže rozlíšiť medzi kód a pripomienky).
  • zarovnané 6 priestorov na rohu aktuálny kód odsadenie, s prázdny riadok vyššie a nižšie.

Príklad:

{the following loop looks for a null character}

   null_index := -1;                   {-1 will mean "not found"}
   test_inx := 0;                      {index of first char}
   done := (len = 0);                  {don't loop if no data}

   while not done do
      begin
            {see if current character is null...}
      if buf [test_inx] = chr (0) then
         begin                         {found a null!}
         null_index := test_inx;       {remember location}
         done := true;                 {terminate loop}
         end

      else
         begin                         {incr inx, check end}
         test_inx := test_inx + 1;
         if test_inx >= len then       {inx is 0-based}
            done := true;
         end;
      end;                             {while not done}

#1-53. Multi-line komentáre môžu sa píše s “{” a “}” na každý riadok, alebo s “{” a “}”, nachádzajúce sa len raz, a to na linkách sami.

#1-54. “{” A “}” znaky sa používajú na spustenie a ukončenie komentáre, nikdy “(*” a “*)” páry.

#1-55. “{” nie je zvyčajne nasleduje medzera, nie je ani “}” zvyčajne predchádza priestoru (ak to nie je zosúladiť ho s predchádzajúcim riadku “}”).

#1-56. Linky by nemal byť dlhší ako 72 bytov, aj keď Pascal/iX umožňuje dlhšie vstupné riadky.

#1-57. Prázdne riadky nestojí nič v čase spustenia, a mali by byť používané voľne na samostatné časti kódu. Príklad:

if ktr > max_ktr then
      max_ktr := ktr;                  {remember new high water}

   done := false;
   while not done do
      begin
      ...

#1-58. “end” vyhlásenie nemusí mať komentovať. Pascal nikdy skontroluje, či váš komentár zhoduje s realitou, tak ako tak.

#1-59. Základné jednotky odsadenie je 3, nie 4 alebo 2.

#1 do 60. Zarážka “begin” s 3 priestory viac ako začať predchádzajúceho riadku. Kód po “begin” (vrátane “koniec”) je na rovnakej úrovni ako “begin”.

#1-61. Pokračovanie riadky sú odsadené 6 viac ako na začiatku prvého riadku.

#1-62. “then” o “, if/then” vyhlásenie je zvyčajne na rovnakom riadku ako zvyšok boolovský výraz, nie na nasledujúcom riadku sama (ak to nie je potrebné pre medzery a potom to je odsadený 6), a nikdy na rovnakom riadku ako vyhlásenie, v nadväznosti na “then”.

#1-63. “else if” postaviť môže zaobchádzať, ako keby bola nová Pascal zostrojte: “elseif”. (I. e.: “if” nasleduje “else” na rovnakom riadku.)

#1-64. “goto 999” je prijateľná metóda vetvenia na konci postupu (alebo funkcií).

#1-65. Žiadne iné “goto” s sú nevyhnutné.

#1-66. Snažte sa udržať postupy pod päť stránok (300 riadkov).

#1-67. Nikdy nepoužívajte slovo “procedure” alebo “function” v komentári v presne všetky písmená. Namiesto toho použite “routine” alebo “PRocedure” alebo “FUnction”.

#1-68. Vždy ukončiť procedúru alebo funkciu s komentárom formulára:

end {nameofroutine proc};

#1-69. Vložte prázdny medzi názov procedure/function a “(” zoznamu parametrov.

#1-70. Vložte prázdny po každom comma v zoznamom parametrov.

#1-71. Dal prázdne okolo subjektov (napr.: “:= “, ” + “, ” – “), a v prednej časti ľavej zátvorky (” [“).

Komentár:

#1-52. Zarovnané pripomienky, aby kód krajší vzhľad. Táto prax je možné pre čitateľa ľahko prečítať kód, alebo pripomienky.

#1-55. Prax vždy po “{” s priestorom a pred “}” odpadu cenný priestor na linke.

#1-56. Dlhé línie nebudú zoznam aj na väčšine terminály, ani nie sú prijateľné pre všetky editory.

#1-58. Ja si dať komentár na “koniec” a strát, keď je viac ako o 10 riadkov z príslušného “begin”.

#1 do 60. Hodnota “3” a príkaz proti “double odsadenie” šetrí miesto a je výsledkom viac čitateľné. Zvážte nasledujúce dva príklady:

zlé:

for i := 1 to 10 do
       begin
           buf [i] := 0;
           foo [i] := 0;
       end;
   if ktr = 0 then
       begin
           if not done then
               begin
                   ...

dobré:

for i := 1 to 10 do
      begin
      buf [i] := 0;
      foo [i] := 0;
      end;

   if ktr = 0 then
      begin
      if not done then
         begin
         ...

Mnoho Pascal programátorov videli “double indentation” štýl, pretože profesor na starosti UCSD Pascal (v roku 1970) používajú tento štýl. Upozorňujeme, že bol predovšetkým učiteľ, nie programátora.

#1-61. Príklad:

if (card_count = max_card_count) and
         all_cards_accounted_for then
      begin
      ...

Cieľom odsadenie pokračovania riadky je, aby bolo jasné, pre čitateľa, že pred line pokračoval na nasledujúcom riadku. Ak nie je extra odsadenie sa použije, potom sa stáva ťažké určiť rozdiel medzi ďalšie výkazy a pokračovanie súčasného ziskov a strát.

Keď som komplexná “and/or”, snažím sa, aby bolo čitateľné, keď robí pokračovanie linky:

zlé:

if ((card_count = prior_card_count) and ((number_of_cards_left
      > cards_for_book)) then
      begin

dobré:

if (      (card_count = prior_card_count)
         and (number_of_cards_left > cards_for_book) ) then
      begin

V zlý príklad, všimnite si, ako “begin” je rozmazaná “and” začína v rovnakom stĺpci.

#1-62. Slovo “then” je syntaktická cukor: to fattens záznam a nemá výkupnú hodnotu. Keď čitateľ vidí “if”, on alebo ona automaticky vie, že “then” sa blíži, nakoniec. Na odsadenie by sama o sebe nestačí povedať čitateľa, že “then” vyhlásenie bolo zistené,. Príklady:

zlé:

if card_count = max_card_count
      then done := true
      else ...

dobré:

if card_count = max_card_count then
      done := true
   else
      ...

Vo vyššie uvedených zlý príklad, čitateľ má mentálne preosiať cez prebytok mnohomluvnost (“then”) v prednej časti “done :=” aby sme pochopili, ovplyvňuje “true” boolovský výraz. V dobrý príklad, čítanie ľavej strane záznamu stačí.

#1-63. “else if” konštrukty sú zvyčajne sa nachádza v jednej z dvoch situácií:

  • “run-on” “if/then/else”. Pre tento konštrukt, “else if” na rovnakom riadku je fyzická čitateľnosť boost.
  • vnorenej “if/then/else”. Pre tento konštrukt, “else” s “, if” odsadený na nasledujúcom riadku je prirodzené.

Príklad “run-on” “if/then/else”:

if token_check ('EXIT') then
      wrapup
   else if token_check ('LIST') then
      do_list
   else if token_check ('PRINT') then
      do_print
   else
      writeln ('Unknown command: ', token);

Poznámka: v uvedených štýl, ja často dať 5 nadbytočné medzery pred prvým “token_check”, tak, že QEDIT príkazu ako LIST “token_check” ukáže všetky tri “token_check” frázy, pekne zladené.

Príklad vnorené “if/then/else”:

if card_count = max_card_count then
      if done then
         ...
      else
         discard_current_card
   else
      if current_card = joker then
         try_best_wildcard
      else
         calculate_score;

Štýl odporúčam proti je nasledovné:

if token_check ('EXIT') then
      wrapup
   else
   if token_check ('LIST') then
      do_list
   else
   ...

Vyššie štýl má drastické čitateľnosť dôsledky, ak je predčasné “page eject” sa vyskytuje v zaradenia medzi “else” linky a tieto “if” line.

#1-64. Pascal chýba “exit” a strát. Obe C a SPL majú nejakú formu “return from this procedure right now” závierky. To je jediné miesto, kde môžem použiť “goto” v Pascale.

#1-67. Toto pravidlo znamená, že editor “find” a “list” príkazy hľadá “procedure” a “function” nikdy náhodou nájdete komentár linky miesto. (Pozri tiež #1-45).

#1-68. Toto je veľmi ľahké nájsť koniec (alebo všetky) procedure(s) s “find” príkaz.

#1-69/70/71. Polotovary, aby kód viac čitateľné, rovnako ako oni, aby angličtinu viac čitateľné. Poznámka: prázdne po čiarku v predchádzajúcej vete. Príklad:

zlé:

fid:=fopen(filename,3,0);

dobré:

fid := fopen (filename, 3, 0);

2. Kódovanie Rozhodnutia

Tento oddiel sa zaoberá voľby, urobené v písomnej forme spustiteľného kódu.

Pokyny

#2-1. Rozhodnite sa, či sa váš štýl je mať funkcie, ktoré vracajú chyby, alebo postupy, ktoré majú postavenie parametre (alebo oboch), a potom držať to.

#2-2. Nemusíte používať “with” pre jednoduchý ukazovateľ dereferencing. Používajte iba “with”, ak indexovanie do poľa.

#2-3. Snažte sa vyhnúť “repeat” slučky, ktoré používajú “while” slučky miesto.

#2-4. Snaž sa “escape” mimo rozsahu “try/recover” blok.

#2-5. Vyhnúť sa “string” s v prospech PACs. A PAC je Zabalený Pole Char s dolná hranica 1.

#2-6. Použitie Pascal/iX rozšírenia, keď je to možné, pokiaľ prenosnosť je hlavným cieľom.

#2-7. “try/recover” postaviť v Pascale/iX je veľmi užitočné pre lov chyby: ako neočakávané a úmyselne spôsobil. (try/recover sa chybové lov mechanizmus trochu podobný úlovok/hod nájsť v niektorých iných jazykoch)

#2-8. Použitie $type_coercion ‘representation’$. Nikdy nepoužívajte noncompatible úroveň druh nátlaku.

#2-9. “Anyvar” parameter typ je užitočný. Zvážte použitie ak chcete prejsť rôznych typov premenných na jeden postup.

#2-10. “Uncheckable_anyvar” možnosť postup by mal byť použité vždy, keď “anyvar” parametre sú deklarované, ak ste konkrétne chcete Pascal/iX prejsť skryté “skutočná veľkosť” parameter.

#2-11. Pri použití “anyvar”, uistite sa, že formálny parameter typu zápasy zarovnanie obmedzenia sa očakáva skutočné typy. I. e.: ak formálny parameter je deklarovaná ako “integer”, potom Pascal/iX bude predpokladať, že všetky adresy, ktoré prešli do parametra sú násobkom 4. Používať “char” (alebo inom byte-aligned typ) ako formálny parameter typu, ak chcete prejsť akékoľvek adresy bezpečne.

#2-12. “Default_parms” postupu, voľba by mala byť považovaná za spôsoby tvorby dlho skutočný parameter zoznamy kratšie (pre bežné prípady).

Komentár:

#2-1. Niekedy som sa vrátiť rýchle celkový výsledok s “good_failed_type” a podrobný chyba v stave parameter. Príklad:

function open_files (var status : hpe_status) : good_failed_type;
   ...
   if open_files (status) = failed then
      report_status (status);

#2-2. Pascal poskytuje “with” vyhlásenie, ktoré môže v niektorých prípadoch poskytujú kompilátor s nádychom o tom, ako optimalizovať pokyny vysiela pre váš kód. Okrem toho, “with” vyhlásenie môže uložiť následné písanie.

Príklad k ničomu, “with”, je:

var
      ptr : hpe_status_ptr_type;
   ...
   with ptr^ do
      begin
      hs_info := 0;
      hs_subsys := 0;
      end;

To je “useless”, pretože kompilátor & na optimalizáciu konverzií by asi urobil len ako dobrú prácu emitovať optimálny kód, keby sme povedal:

ptr^.hs_info := 0;
      ptr^.hs_subsys := 0;

Všimnite si, že kód trvalo päť riadkov pomocou “with”, vyhlásenie, a dva riadky bez neho.

Nakoniec skutočnosť, že “hs_info” a “hs_subsys” sú v skutočnosti polia záznamu poukázal na “ptr” je trochu nejasné, keď “with” sa používa.

Príklad užitočné “with” je:

var
      statuses : array [0..9] of hpe_status_type;
   ...
   with statuses [k] do       {optimize [email protected] fields}
      begin
      hs_info := 0;
      hs_subsys := 0;
      end;

Ja to považujem napríklad “useful”, pretože na optimalizáciu konverzií, by sa mal viac práce sa snaží zostaviť optimálny kód pre ekvivalentné non-s závierky:

statuses [k].hs_info := 0;
   statuses [k].hs_subsys := 0;

V uvedených príkladoch, je lákavé zladiť “:=”s, pravý-najviac “:=” blok priradenie závierky. V minulosti som často to, keď som mal štyri alebo viac podobných úloh v rade.

Výhodou je, zvýšenú čitateľnosť, pretože sme, aby bolo zrejmé, že údaje týkajúce sa (kvôli aligned “:=”s). Nevýhodou je, že jednoduchý QEDIT príkaz navrhnuté tak, aby zoznam, kde sa “hs_info” pole sa zmení (napr.: LIST “hs_info :=”) sa nepodarí. Zistil som, že vyhľadávania-pre-úlohy schopnosť prevažujú údaje-je-súvisiace prospech, pre mňa.

#2-3. Keď “repeat” slučky sa stretli, čitateľ nebude vedieť, čo ukončenia podmienkou je až o mnoho viac riadkov program zdroj sa čítať. To znamená, že on alebo ona nebude môcť skontrolujte správne nastavenie ukončenia stave. “while” slučky vyhýba to problém, pretože ukončenie stav je jasne špecifikované v hornej slučky.

Opakovania slučky môžu byť obvykle sa zmenili na chvíľu slučky ľahko:

predtým:

repeat
      begin
      ...
      end
   until
      buf [inx] = 0;

po:

done := false;
   while not done do
      begin
      ...
      done := (buf [inx] = 0);
      end;          {while not done}

#2-4. “non-local escape” náklady tisícky cyklov CPU čas na vykonanie. Skrátka, nikdy v pláne na využitie tejto postavit ako normálny spôsob návrate z režimu. Príklady:

zlé:

procedure do_work;         {note:  no status parameter!}
      ...
      if problem then
         escape (i_failed);
      ...

dobré:

 procedure do_work (var status : hpe_status_type);
      label
         999;
      ...
      if problem then
         begin
         status := my_failure_status;
         goto 999;            {exit}
         end;
      ...
   999:

      end {do_work proc};

#2-5. Reťazce skryť obrovské množstvo pomaly a trochu nesprávne kompilátor-generuje kód. String zreťazenie, najmä, môže mať za následok “memory leaks”, kde sa váš proces beží z haldy priestor. PACs sú messier na riešenie, ale oveľa efektívnejšie. To je výkon verzus estetiky obchodu preč.

#2-6. Pascal/iX je veľmi užitočné, jazyk, práve preto, že má veľké telo rozšírení štandardného Pascal. Ak sa vám vyhýbajú ich použití by ste byť lepšie programovanie v ANSI C alebo C++.

#2-7. “Try/recover” nie je zaručené, aby sa chytiť všetky chyby, ktoré sa vyskytujú v ňom. Neočakávané chyby (napr.: neplatný index, zlé virtuálna adresa) spusti operačný systém rutinné nazýva trap_handler, ktorý bude “walk” späť prostredníctvom zásobníka markerov pri pohľade na najnovšie “try/recover” blok. Tento “chodiť” môže zlyhať, ak váš zásobník je poškodený, a “try/recover” nebude nájdený. Ak sa to stane, a ak je to vhodné pasce handler (napr.: XCODETRAP) nebol ozbrojený, váš proces bude prerušená.

#2-8. Typ nátlaku je jedným z najlepších rozšírení v Pascale/iX. Poskytuje kontrolovaným spôsobom vyššieho Pascal typu kontroly. $type_coercion smernica hovorí Pascal/iX čo úrovni typ nátlaku chcete povoliť vo vašom programe. O päť rôznych úrovniach existovať. Úroveň vrelo odporúčam, je zastúpenie. Táto úroveň umožňuje vyjadrenie jedného typ byť nútení (zaobchádzať ako s) iný druh vtedy a len vtedy, ak dva typy sú presne rovnakej veľkosti (v jednotkách bitov, nie bajtov).

Na noncompatible úrovni hovorí Pascal/iX, že by tam mali byť žiadne obmedzenia na typ nátlaku. To vedie k zaujímavým chyby v programoch. Niektoré MPE/iX systém po zlyhaní, možno vysledovať na použitie tohto druhu typ nátlaku nesprávne. Nasledujúci príklad ukazuje, ako noncompatible môžete skryť chyby.

za predpokladu, že:

var
      big_ptr     : globalanyptr;
      my_address  : integer;
      small_ptr   : localanyptr;

zlé:

$type_coercion 'noncompatible'$
   my_address := integer (big_ptr);   {will get half of data!}
   my_address := integer (small_ptr); {will get 32 bit value}

dobré:

$type_coercion 'representation'$
   my_address := integer (big_ptr);   {will get syntax error}
   my_address := integer (small_ptr); {will get 32 bit value}

V zlý príklad, nátlaku z big_ptr výsledky v nastavenie my_address na horných 32 bitov big_ptr (t. j.: priestor id), ticho strata dolnej 32 bitov adresy. V dobrý príklad, Pascal/iX bude generovať syntaktická chyba v snahe prinútiť 64-bitové vyjadrenie (big_ptr) do 32-bitová hodnota (integer).

#2 až 9. “anyvar” je Pascal/iX rozšírenie “var”. Keď formálny parameter je deklarovaná ako “anyvar”, kompilátor umožňuje, aby každá premenná byť odovzdané ako skutočný parameter. Bez takú funkciu, a bez objektovo-orientovaného Pascal, ste nemohli napísať jednotný postup, ktorý by nula (vymazať) ľubovoľnej premennej (pozri nižšie uvedený príklad).

V predvolenom nastavení, keď parameter je deklarovaná ako anyvar, Pascal/iX budú prechádzať v adresy skutočného parametra *a* skryté celé číslo-od-hodnota, ktorá sa zaznamenáva veľkosť skutočného parametra. Nasledujúci príklad ukazuje, čo je odovzdaný pre formálny parameter ako: “anyvar foo : integer”, a vplyv na “sizeof (foo)” v rámci postupu:

Actual parameter type Hidden size field sizeof (foo)
char 1 1
shortint 2 2
integer 4 4
longint 8 8
real 4 4
longreal 8 8
hpe_status (see #1-24) 4 4
> packed array [1..80] of char 80 80

#2-10. Používam “anyvar” pomerne často. Jeden príklad je:

procedure zero_var (anyvar foo : char);
         {Purpose: zero every byte in the parameter}
      var
         bytes_left           : integer;
         byte_ptr             : ^char;

      begin

   $push, range off$
      byte_ptr := addr (foo);
      bytes_left := sizeof (foo);  {Note: gets actual size!}

      while bytes_left > 0 do
         begin                     {zero one byte}
         byte_ptr^ := chr (0);
         bytes_left := bytes_left - 1;
         byte_ptr := addtopointer (byte_ptr, 1);
         end;
   $pop$          {range}

      end {zero_var proc};

Poznámka: komentár k $pop$…umožňuje mi pripomenúť, aké možnosti $pop$ je vraj reštaurovania.

V Pascale/iX, $push$ ukladá štátu, väčšina kompilátor možnosti, a $pop$ obnovuje ich. Teda, $push, rozsah off$ a … $pop$ dočasne vypne “range” možnosť, a potom restores to staré štátu … čo je výrazne iné, než stačí ju zapnúť, keď “done”!

Samozrejme, Pascal/iX umožňuje ešte rýchlejší spôsob vynulovania premennej, ktorá sa stane aj pracovať s možno začiarknuť anyvar parametre. Celý kód z vyššie uvedeného postupu (medzi “begin” a “end”) môže byť nahradené:

fast_fill (addr (foo), 0, sizeof (foo));

#2-12. Nasledujúci príklad postupu, ktoré väčšina používateľov by sa volať “false” v druhý parameter, ukazuje, užitočnosť “default_parms”:

const
      print_with_cr      = 0;
      print_without_cr   = 1;

   procedure print_msg (
                  msg                  : str80;
                  cr_or_no_cr          : integer)
         option default_parms (
                  cr_or_no_cr          := print_with_cr);

      var
         cctl_val   : shortint;

      begin

      if cr_or_no_cr = print_without_cr then
         cctl_val := octal ('320')
      else
         cctl_val := 0;

      print (msg, -strlen (msg), cctl_val);
            {Note: ignoring errors from print intrinsic}

      end {print_msg};
   ...
   print_msg ('Starting...', print_without_cr);
   print_msg ('Ending');               {does a CR/LF at end}

Všimnite si, že by som nemohol použiť “default_parm” pre parameter, ktorý je vynechané menej ako o 75% času.

3. Problémy s výkonom

Dva najväčšie problémy s výkonom v Pascale/iX programy sú pomocou vstavaného I/O, a povrázky.

Usmernenia:

#3-1. Vyhnúť Pascal I/O. Použiť intrinsics miesto.

#3-2. Vyhnúť Pascal I/O. Použiť intrinsics miesto. Je to oplatí povedať dvakrát!

#3-3. Vyhnúť reťazce v výkon kritických oblastiach.

#3-4. Vypnite rozsah kontroly ($range off$), iba ak ste si istí, že váš program pracuje správne.

#3-5. Použitie Pascal/iX na optimalizáciu konverzií ($optimize on$).

Komentár:

#3-1. Ak ste zapuzdrenia I/O hovor, a potom ich základné realizácia môže byť ľahko zmenené na použitie MPE intrinsics. To tiež pomáha prenosnosť cez operačné systémy a cez jazykov. “print_msg” postup pri komentár #2-12 je príklad.

Druhý dôvod pre zamedzenie Pascal I/O konštrukty je efektívnosti. Pascal/iX I/O rutiny sú veľmi neefektívne. Tento metodický pokyn je platný pre väčšinu jazykov.

#3-3. String výrazy spôsobiť kompilátor vyžarujú veľa hovorov “helper” rutiny. Namiesto rozdelenia jednej pracovnej oblasti do zásobníka, tieto rutiny prideliť (a vyhradenie) mnoho pracovných oblastí, na haldy. To môže byť veľmi náročná činnosť, a môže viesť k strate haldy priestor, a prípadné ukončenia procesu.

#3-5. Ak je váš program beží správne unoptimized, a má problém optimalizované, potom existuje pravdepodobne jeden (alebo viac) uninitialized premenných. Druhou najčastejšou problému je použitie ukazovateľov tak, že nástroj na optimalizáciu nemá očakávať, že (najmä pri prístupe lokálne premenné cez ukazovatele).

4. Prenosnosť

Prenosnosti programy napísané v Pascale/iX môže byť rozšírený o niekoľko techník. Nezabúdajte však na to, že väčšina iných Pascal implementácie nie sú tak bohaté ako Pascal/iX. Delphi a Turbo Pascal (na IBM PC compatibles) poskytovať niektoré rovnaké funkcie ako Pascal/iX.

#4-1. Vyhnúť sa týmto Pascal/iX rozšírenia: extensible, readonly, anyvar, option, uncheckable_anyvar, default_parms, globalanyptr.

#4-2. Vyhnúť väčšine $ smernice (napr.: $extnaddr$).

#4-3. Použitie typ nátlaku iba pre typy rovnakej veľkosti. (Dobrý tip aj keď ste nikdy v úmysle port kód!) Väčšina PC založené na Pascaloch mať formu druh nátlaku. Môžu ju označovať ako “type casting”.

#4-4. Vyhnúť sa “crunched” záznamy. Aj väčšina C jazyky nemajú funkčný ekvivalent. To zahŕňa vyhnúť “$HP3000_16$”.

#4-5. Zapuzdrenie “strange” konštrukciami, kde je to možné.

#4-6. Zapuzdrenia I/O hovorov. To nie je jazyk prenosnosť problém toľko ako operačný systém and/or výkonu problém.

#4-7. Udržiavajte zdrojový kód linky krátke (72 znakov na riadok).

#4-8. Použiť používateľom definované typy ako “int16” a “int32” namiesto “shortint” alebo “integer”. Poznámka:: to je veľmi dôležité pre C programátorov!

#4-9. Uvedomte si, že polia, záznamy môžu byť balené odlišne na rôzne stroje.

#4-10. Štandardné Pascal neumožňuje ukazovatele, ktoré poukazujú na premenné. (Môžu len bod do haldy.)

5. Zhrnutie

Najkratšia zhrnutie táto kniha je pravdepodobne: môžete súdiť knihu podľa obalu. Ak program vyzerá pekne, asi to je pekné.