Mi a különbség a funkcionális és imperatív programozás között?

Talán az a baj, hogy a C++ csak nagyon nyögvenyelősen és erőltetten támogatja a funcionális programozást, olyan mintha csak azért tették volna bele, mert divat.

Ha jót akarsz magadnak, inkább egy olyan nyelvet keresel, ami tényleg funkcionális programozásra van kitalálva. Már ha tényleg érdekel a funkcionális programozás.

#include <iostream>

//ettol--------------------------

// https://www.gyakorikerdesek.hu/szamitastechnika__programozas..

#include <string>

using namespace std;

unsigned long faktorialis_funkcionalis(const unsigned int n){

if (n<2)

return 1; else

return n*faktorialis_funkcionalis(n-1);

}

unsigned long faktorialis_imperativ(unsigned int n){

unsigned long szorzat=1;

for (;n>0;n--)

szorzat*=n;

return szorzat;

}

bool tukorszo_e_funkcionalis(const string str){

if (str.length()<2)

return true; else

if (str[0]!=str[str.length()-1])

return false; else

return tukorszo_e_funkcionalis(str.substr (1,str.length()-1-1));

}

bool tukorszo_e_imperativ(string str){

if (str.length()<2)

return true;

for (size_t i=0;i<str.length()/2;i++)

if (str[i]!=str[str.length()-1-i])

return false;

return true;

}

//eddig--------------------------

int main ()

{

cout << faktorialis_imperativ(0) << endl;

return 0;

}

@scriba-nak :

Mivel a funkcionális programozás egy programozási paradigma és a C++ Turing-teljessége miatt lehet benne programozni funkcionálisan akkor is, ha nem használjuk ennek nyelvi szinten való támogatását. Egy Turing-teljes nyelven lehet programozni funkcionálisan akkor is, ha nincs ennek nyelvi támogatása, csak akkor nincs rá automatikus ellenőrzés, hogy betartjuk e ezt a paradigmát, meg ez annyira nagy overhead-al járhat mely miatt bizonyos esetekben annyira megnőhet a futási idő, a stack, a heap használat, hogy dugába dől az egész. Sokat segít, ha erre optimalizál a fordító/interpreter. Viszont egyszerű példák esetében nem olyan szörnyű a helyzet az erre való optimalizáció hiányában.

------

Kérdezőnek:

Az imperatív programozásban az értékadó utasítások megfelelő sorrendben történő kiadására koncentrálódik. ... stb.

A tankönyvi megfogalmazástól eltérően megfogalmazva: majdnem minden esetben ezaz a valami amivel találkozik az aki elkezd a programozással fogalkozni. Az a ki nem mondott tévkép van a fejében, úgy ,hogy tudatosan bele se gondol, hogy nincs is olyan programozási izé melyben egészen máshogy kell gondolkoni, ahol ettől lényegesen eltérő szemléletmódra van szükség. Ebben változók vannak melyek értékeket vesznek fel mely felvett értékek a futás során megváltozhatnak, lehet írni valami kimeneti eszközre (és olvasni bemeneti eszközről). Pl a képernyőre lehet rajzolni mely rajzot folyamatosan felül lehet írni, ez az animáció. Van rajzoló függvény/eljárás ami pl egy vonalat rajzol. Ez nem más mint annak a függvénynek/eljárásnak a mellékhatása. Ha egy változó értéke megváltozik akkor az is mellékhatás. Egy adott pillanatban egy adott állapotban van a rendszer, ahogy valamit írunk/rajzolunk a képernyőre vagy változó értékét megváltoztatjuk akkor egy más állapotba lép a rendszer a mellékhatások során. A több szkript nyelveken az meg még egy extra mellékhatás, hogy eddig nem létező új változókat lehet létrehozni és meglévőeket törölni, sőt a meglevő változó típusát futás során meg is lehet változtatni, sőt új típusokat is lehet létrehozni futás közben stb.

Ezzel szemben a funkcionális programozásban (ha tisztán funkcionális) nincsenek állapotok, nincsennek mellékhatások (nem számít, hogy mikor hanem az számít, hogy melyik függvényt hívtam meg), nincsennek változók illetve olyan értelemben van, hogy függvények paraméterei, de egy változó sosem változik. Egyszeri értékadás lehetséges, ami azt jelenti hogy definiálom annak a konstansnak az értékét. Minden konstansszimbólum egyben paraméter nélküli függvényszimbólum egyben. Tulajdonképpen a matematika világát tükrözi. Nincs olyan a matekba, hogy a monndjuk a sin(90) hol ennyi hol annyi és közben valami változás lesz valamiben, vagy bármilyen másik függvény esetében sem. A pi vagy akármelyik konstans értéke sem lesz valamikor ennyi valamikor annyi. A funkcionális programozásban nagy hangsúly van a függvényeken, itt a másik paradigmával szemben azt definiáljuk, hogy mit számoljon nem az hogy hogyan.

Példakód: pastebin pont com / pL5nYNDq

unsigned long faktorialis_funkcionalis(const unsigned int n)

Definiálom, hogy n<2 esetében 1 különben n*faktorialis_funkcionalis(n).

unsigned long faktorialis_imperativ(unsigned int n)

itt az n paraméter értékét is mindig folyamatosan felülírom és a szorzat változó-t is mely mindig a pillanatnyi szorzat értéket tartalazza.

bool tukorszo_e_funkcionalis(const string str)

Tükörszó egy szó, ha fordítva is ugyanaz, de ehhez definiálni kéne mi az hogy fordítva. E helyett úgy definiáltam, ha a hossza kisebb mint 2 akkor tükörszó különben ha az első és utolsó karaktere nem egyezik meg akkor nem, különben az igazságértéke megegyezik azzal mint az első és utolsó karakter-t levágva kapott string esetében. Nem vágtam le, mivel az mellékhatás, hanem e helyett egy matematikai függvény szerint stringből string-be képező függvényt használtam. Igaz metódushívást használtam erre, de mivel állapotmentes így tekinthető matematikailag/ funkcionálisan függvénynek.

bool tukorszo_e_imperativ(string str)

Értelemszerűen működik. Itt a ciklusváltozó növelése a mellékhatás.

Mj.:

Tisztán funkcionális nyelv a Haskell, ha érdekel ezzel ismerkedj!