From Human Computer Interaction Laboratory

Jump to: navigation, search

(Zpět na VRECKO Manuál)

Zde jsou k dispozici obecné programátorské tipy a triky, které se hodí při tvorbě libovolného projektu (nejen ve VRECKU). Tipy jsou pro různé stupně pokročilosti, včetně začátečnických.

Předpokládá se použití MS Visual Studio 2010, ale některé triky platí i pro jiná vývojová prostředí. (Pozn. Vít Kovalčík: Něco z toho jsou reálné příklady chyb a problémů, se kterými jsem se vícekrát setkal u studentských prací)


Hledání informací o funkci/metodě

VS už má samozřejmě funkce pro doplnění syntaxe ("vre" -> Ctrl+Space -> "doplní na "vrecko", pokud máte správné #include ... a samozřejmě zvládá doplňovat i další názvy proměnných, funkcí, tříd a metod).

Pak je tu možnost zobrazení parametrů metody/funkce/šablony ("strcpy(" -> Ctrl+Shift+Space -> zobrazí parametry. Většinou funguje i bez oné klávesové zkratky, ale občas se ty klávesy hodí).

I tak ale může být potřeba najít deklaraci nebo definici dané funkce nebo metody. I proto, že u deklarace bývají občas komentáře k použití. Pokud se jedná o standardní funkci (např. strcmp), informace jsou na internetu, lehce vás tam přenese klávesa F1. Pokud se jedná o speciální metodu ve větším projektu, stačí kliknutí pravým tlačítkem na ni a v kontextovém menu zvolit "Go to declaration/definition". (Bývá praktické si na to nastavit klávesovou zkratku v Tools -> Options -> Environment -> Keyboard -> "Edit.GoToDefinition" a "Edit.GoToDeclaration")

Pokud hledáte použití dané funkce v projektech, je možné využít opět kontextové menu a položku "Find All References".

Příkazy v kontextovém menu nemusí vždy fungovat nebo můžete chtít najít speciální použití nebo část kódu - pro tyhle účely se nebojte používat funkci Edit -> Find In Files (Ctrl + Shift + F), která rychle prohledá všechny soubory ve všech projektech. Zde se dají používat nejen názvy metod, ale i znaky, které se dají očekávat kolem, např. "::createAbility" vás celkem spolehlivě dostane na definici metody createAbility.

V kontextovém menu se nachází ještě jedna praktická položka - Go To Header File - opět bývá praktické si ji nastavit na nějakou klávesovou zkratku (Tools -> Options -> Environment -> Keyboard -> "EditorContextMenus.CodeWindow.GoToHeaderFile").


Debugování

Pokud spouštíte program z VS pomocí F5, automaticky se k němu připojí debugger a v případě pádu můžete zkoumat aktuální stav proměnný apod. Také je možné program kdykoliv zastavit (užitečné např. když se zacyklí) - provede se přepnutím do VS a v menu Debug -> Break All. Běh programu se obnoví zase pomocí F5.

Víc použivaná je asi zkratka pro zabití programu :) Shift + F5

Pokud aplikaci spustíte pomocí Ctrl + F5, nebude se sice debugovat, ale v případě pádu je i tak možné dodatečně připojit debugger a opět se chovat, jako by byl připojen od začátku.


Konstanty namísto pevných čísel

Pokud se někde v programu potřebujete zapsat číslo, je velmi často (skoro vždy) lepší si pro něj nadefinovat konstantu, např. namísto:

int myArray[100];
...
for (int i = 0; i < 100; ++i) ...

je lepší používat:

#define MYARRAY_LENGTH 100 // nebo: const int MYARRAY_LENGTH = 100;
int myArray[MYARRAY_LENGTH];
...
for (int i = 0; i < MYARRAY_LENGTH; ++i) ...

Kód, který s polem nebo čímkoliv jiným pracuje, je často rozházený po více souborech, takže druhý přístup mívá několik výhod:

  • menší riziko překlepu
  • přehlednost
  • možnost pozdější úpravy

Používání proměnné typu "auto"

Praktický důsledek implementace nového standardu C++ nazvaného C++0x. Namísto psaní například

std::vector<int>::iterator iter = myVector.begin();

je možné použít

auto iter = myVector.begin();

a stejně to funguje i v dalších případech, kde je předem známý typ návratové hodnoty. Ve Vrecku je to například velmi užitečné při posílání requestu a obdržení návratové hodnoty:

auto returned_value = reqOutputMyRequest->request(...);

Předávání složitých parametrů do funkcí

Tento kód je obvykle špatně (resp. bude fungovat, ale je neefektivní):

void my_function(std::vector<int> param) {
}

Při volání této funkce se vložené pole zduplikuje a teprve pak se pošle dále. Při návratu se zase zruší. Lepší řešení je použít ukazatel nebo referenci:

void my_function(std::vector<int> &param) {
}

Stejné pravidlo platí například pro parametry typu std::string

(Samozřejmě spousta programátorů tohle všechno zná, ale opravdu se s tímhle problémem běžně setkávám.)

Kraťounké metody typu inline

Pokud má vaše třída metodu například getVertex, mohlo by se zdát, že ji zapíšeme do hlavičkového souboru třeba jako

class MyClass {
    osg::Vec3 * getVertex(int index)
    ...
 };

a do souboru .cpp přibude:

osg::Vec3 * MyClass::getVertex(int index) {
  return &vertices[index];
}

To ale znamená, že kvůli zjištění pozice každého vertexu se bude vyvolávat metoda, procesor bude vykonávat spoustu funkcí spjatých s managementem a program se zpomalí. Lepší je využít klíčového slova inline a zapsat ji celou jen do hlavičkového souboru, tedy:

class MyClass {
    inline osg::Vec3 * getVertex(int index) { return &vertices[index]; }
    ...
 };

To způsobí, že tato metoda přestane být metodou v pravém slova smyslu a její kód se přímo vloží na místa, kde by se normálně volala. To je samozřejmě rychlejší, i když u složitějších metod by to znamenalo, že se zvětší velikost kódu, proto je dobré to dělat jen u menších metod. VS standardně dokáže odhadnout, kdy je dobré použít inline metody, ale i tak je nutné ji zapsat do hlavičkového souboru a doporučuji použít klíčové slovo inline (u Vrecka je ono odhadování momentálně vypnuté, takže inline metody jsou jen ty se slovem "inline")

Pamatování mezivýsledků

(Tohle jsem viděl v ještě mnohem horší podobě)

Ukázka špatného kódu:

for (int a = 0; a < getPolygonsCount(); a++) {
   glNormal3f(getVertex(getPolygon(a).v1).normal.x,
              getVertex(getPolygon(a).v1).normal.y,
              getVertex(getPolygon(a).v1).normal.z);
   glVertex3f(getVertex(getPolygon(a).v1).coordinates.x,
              getVertex(getPolygon(a).v1).coordinates.y,
              getVertex(getPolygon(a).v1).coordinates.z);
   glNormal3f(getVertex(getPolygon(a).v2).normal.x,
              getVertex(getPolygon(a).v2).normal.y,
              getVertex(getPolygon(a).v2).normal.z);
   glVertex3f(getVertex(getPolygon(a).v2).coordinates.x,
              getVertex(getPolygon(a).v2).coordinates.y,
              getVertex(getPolygon(a).v2).coordinates.z);
   glNormal3f(getVertex(getPolygon(a).v3).normal.x,
              getVertex(getPolygon(a).v3).normal.y,
              getVertex(getPolygon(a).v3).normal.z);
   glVertex3f(getVertex(getPolygon(a).v3).coordinates.x,
              getVertex(getPolygon(a).v3).coordinates.y,
              getVertex(getPolygon(a).v3).coordinates.z);
}

Funkce getPolygon se se stejnými parametry volá osmnáctkrát (a nebyla inline, viz výše). Každý getVertex se volá šestkrát se stejnými parametry. Tohle by bylo rychlejší a jednodušší na údržbu:

Polygon *p;
Vertex *v;
for (int a = 0; a < getPolygonsCount(); a++) {
   p = &getPolygon(a);

   v = &getVertex(p->v1);
   glNormal3f(v.normal.x, v.normal.y, v.normal.z);
   glVertex3f(v.coordinates.x, v.coordinates.y, v.coordinates.z);

   v = &getVertex(p->v2);
   glNormal3f(v.normal.x, v.normal.y, v.normal.z);
   glVertex3f(v.coordinates.x, v.coordinates.y, v.coordinates.z);

   v = &getVertex(p->v2);
   glNormal3f(v.normal.x, v.normal.y, v.normal.z);
   glVertex3f(v.coordinates.x, v.coordinates.y, v.coordinates.z);
}

Pokud si navíc nadefinuji vrcholy polygonu ne jako proměnné v1, v2, v3, ale jako statické pole v[3], údržba kódu se ještě zjednodušší:

Polygon *p;
Vertex *v;
for (int a = 0; a < getPolygonsCount(); a++) {
   p = &getPolygon(a);
   for (int b = 0; b < 3; b++) {
      v = &getVertex(p->v[b]);
      glNormal3f(v.normal.x, v.normal.y, v.normal.z);
      glVertex3f(v.coordinates.x, v.coordinates.y, v.coordinates.z);
   }
}

Mohlo by se zdát, že díky cyklu bude kód o něco pomalejší, ale kompilátor nejspíš v tomto případě provede tzv. loop unwinding a cyklus ve zkompilovaném programu nebude (viz [1])

Optimalizace iterátorů

Pomalejší kód:

for (vector::iterator iter = vec.begin(); iter != vec.end(); iter++) ...

Rychlejší kód:

for (vector::iterator iter = vec.begin(); iter != vec.end(); ++iter) ...

Trik je v tom, že v prvním případě jde o tzv. post-increment, kdy proměnná zvedne svoji hodnotu o jednu jednotku, ale je nucena (díky specifikaci C++) vrátit předchozí hodnotu. Díky tomu musí dočasně vytvořit novou dočasnou proměnnou typu iterátor se stávající hodnotou, zvýšit iterátor a vrátit onu dočasnou hodnotu. Ta se nepoužije, takže je okamžitě smazána.

V druhém případě jde o pre-increment, kde se hodnota zvýší a vrátí se přímo nová hodnota, resp. reference na již existující iterátor. Žádná dočasná proměnná se nevytváří, kód je tedy rychlejší.

Early exit on error

Tento tip pojednává o zápisu funkcí/metod a týká se mých preferencí a zvyků (by Vít Kovalčík). Můžete mít jiné priority, což je v pořádku - toto je jen tip.

Často vidím kód ve stylu:

void myFunc() {
    if (func1()) {
        if (func2()) {

             ... dlouhý ...
             ... a ...
             ... složitý ...
             ... hlavní ...
             ... kód ...

        } else {
            printf("Nastala chyba 2");
        }
    } else {
         printf("Nastala chyba 1");
    }
}

Samozřejmě je v pořádku a postupné programování k němu trochu svádí. Nicméně je nečitelný a při pozdějších úpravách se může vymstít. Osobně používám spíš styl vypořádat se s chybami co nejdřív a dál řešit jen kód, který vykonává hlavní činnost. Odpadají tím také spousty nečitelných zanoření. Příklad nahoře by vypadal takto:


void myFunc() {
    if (!func1()) {
         printf("Nastala chyba 1");
         return;
    }

    if (!func2()) {
         printf("Nastala chyba 2");
         return;
    }

    ... dlouhý ...
    ... a ...
    ... složitý ...
    ... hlavní ...
    ... kód ...

}

Záměrné neplatné hodnoty proměnných

Tohle většina lidí zná, ale pro jistotu...

Pokud máte vlastní proměnnou uchovávající nějakou hodnotu, je velmi často výhodné si nadefinovat nějaké číslo, které bude reprezentovat neplatnou hodnotu. Toto číslo je obvykle 0, -1, 0xFFFFFFFF nebo MAXINT podle toho, co je možné v dané reprezentaci použít a pokud možno jako hodnota samotná nedává smysl. Tuto hodnotu je ideální definovat jako makro/konstantu (výhody: nemusí si to člověk pamatovat, lze to změnit a zmenšuje se riziko překlepu). Typické použití je následující:

#define INVALID_OBJECT_ID  0
unsigned int objectId = INVALID_OBJECT_ID;

Proč vůbec rezervovat neplatnou hodnotu?

  • Je možné si zapamatovat stav nevyplněno/neinicializováno, takže není nutné používat druhou proměnnou (např. bool objectIdInitialized) - správa kódu je jednodušší a hlavně hrozí mnohem menší riziko chyb v tom, že některá čast kódu omylem upraví jen jednu z proměnných.
  • Je možné předávat tuto hodnotu do funkcí - může pak místo skutečné hodnoty znamenat nedefinováno/nevím
  • Je možné tuto hodnotu vracet z funkce - vhodné pro signalizaci chyby nebo nestandardního stavu.


Bezpečnější podmínky

Namísto

if (x == 3) ...

je lepší používat

if (3 == x) ...

Výsledný kód je stejný, ale v prvním připadě se může lehce stát překlep a když jeden symbol "rovná se" vypadne, tak je kód pořád platný, ale dělá něco jiného, než co zamýšlel programátor (přirazení 3 do proměnné x a kontrola, jestli je 3 větší než 0, což je vždy pravda).

U druhého přístupu při vynechání rovnítka ohlásí kompilátor chybu.

"for" cykly pro opakované vykonání podobných (nejen stejných) sekcí

Namísto

object1.func1();
object1.func2();
object1.func3();
object1.func4();
object1.func5();
...
object2.func1();
object2.func2();
object2.func3();
object2.func4();
object2.func5();
...

je přehlednější (a v budoucnu spravovatelnější) použití:

for (i = 0; i < 2; ++i) {
  auto tmpObject = i ? &object2 : &object1;
  tmpObject->func1();
  tmpObject->func2();
  tmpObject->func3();
  tmpObject->func4();
  tmpObject->func5();
  ...
}

Toto oceníte ve chvíli, kdy je navíc potřeba před voláním funkcí vykonat další shodné výpočty, ladící výpisy apod.

Stejně se dá postupovat, pokud dva kusy kódu vypadají podobně, jen se v nich mění pár řádků - vše se umístí do cyklu a různorodé akce se vykonají jen v daných průbězích cyklu.

Celý tento příspěvek se může zdát primitivní, ale opravdu jsem v praxi nejednou viděl pod sebou zkopírovaný stořádkový kus kódu, kde se jednotlivá opakování lišili jen v pěti řádcích.

Zvykněte si uvolňovat paměť

Pokud někde alokujete paměť je výhodné zrovna počítat s uvolňováním a napsat příslušný řádek kódu... jinak se často v budoucnu stane, že se problémy s neuvolňováním paměti začnou kupit a je potřeba je opravit když projekt nabobtná, což je výrazně obtížnější.

(Zpět na VRECKO Manuál)