Da li u C-u moze kao u paskalu da se...

[ Goq @ 08.07.2005. 10:06 ] @

... definise funkcija "unutar" funkcije, i da moze da ugrabi sve varijable svog "roditelja". Evo sta hocu:

Code:

function roditelj(x:integer):integer;
var y:integer;
function dete:integer;
  begin
   dete:=x+y;
  end;
begin
roditelj:=dete;
end;

[ NastyBoy @ 08.07.2005. 10:16 ] @

Po vazhecem standardu - ne.

[ Goq @ 08.07.2005. 10:24 ] @

Stvarno jadno, niko ne misli na nas strukturalne programere...:)
Da li to znaci da je ovo resenje (koliko god ruzno izgledalo) jedino:

Code:

class Roditelj
{
public:
static int x,y;
   class Dete
    {
     public:
     int Poziv(void){return x+y;};
    }d;
int Poziv(int x_)
{
  x=x_;
  return d.Poziv();
};
};

_{[Ovu poruku je menjao Goq dana 08.07.2005. u 11:40 GMT+1]}

[ MilošV @ 08.07.2005. 10:46 ] @

Zasto bi to morao bas tako da radis? Ako vec definises jednu funkciju, ne vidim kakav je problem da definises drugu odmah pored nje... Posle ih pozivas kako hoces.
Nekako mi je to taman u definiciji strukturnog programiranja :)

[ IDE @ 08.07.2005. 11:53 ] @

milos je u pravu...
zasto praviti f-ju unutar f-je, kada mozemo jednu pored druge napisati, i koristiti kada god hocemo...

[ Goq @ 08.07.2005. 12:21 ] @

Zato sto dve odvojene funkcije ne mogu da "dele" neku varijablu (tj. da varijabla bude vidljiva iz obe funkcije), osim ukoliko ona nije "globalna".
Evo sta bih voleo da mogu u C-u:

Code:

function roditelj(x:integer):integer;
var y:integer;
function dete:integer;
  begin
   dete:=x+y;
  end;
begin
y:=1;
roditelj:=dete;
end;

begin
writeln(roditelj(2));// ispisuje 3
end.

Vi mi predlazete ovo:

Code:

#include....
int x,y;//globalne

int dete(void)
{
return x+y;
};

int roditelj(int x_)
{
y=1;
x=x_;
return dete();
}
main()
{
printf("%d", roditelj(2));
};

A ja bih izbegao "globalne" promenljive.

[ Goq @ 08.07.2005. 12:50 ] @

Probacu da skinem neki "pascal to C" konvertor, pa da vidim sta ce oni da mi kazu :)

[ Goq @ 08.07.2005. 13:07 ] @

Dobio sam pomoc od programa PtoC, zanimljivo ali ipak nedovoljno elegantno, nastavicu dalje kako se snadjem....

Code:

#include <cstdlib>
#include <iostream>
using namespace std;
typedef int integer;

static integer dete(integer& x, integer& y)
{
  integer dete_result;
  dete_result=x+y;
  return dete_result;
}

integer roditelj(integer x)
{
    integer y;

integer roditelj_result;
y=1;
roditelj_result=dete(x, y);
return roditelj_result;
}

int main(int argc, const char* argv[])
{
printf("%d",roditelj(2));
system("PAUSE");
return EXIT_SUCCESS;
};

_{[Ovu poruku je menjao Goq dana 08.07.2005. u 14:30 GMT+1]}

[ salec @ 08.07.2005. 13:43 ] @

Pretpostavljam da zelis da sakrijes detalje implementacije "roditelja" od ostatka programa (koji mozda rade ili su radili neki drugi programeri) odnosno da ne brines o sudaranju imena pomocnih funkcija i varijabli sa nekim tudjim.

Mislim da se to sto zelis u C-u postize iskljucivo putem izdvajanja roditelja i dece u zaseban "porodicni"

sors fajl, pa onda ono sto su samo njihova posla (deljene varijable izmedju roditelja i dece, deklaracije i definicije dece ) declarises static i "ne vide" se izvan tog fajla.

E sad, naravno, to resenje je kratkog daha, jer imas samo jedan nivo "skrivenosti" pa ako "deca" imaju svoju "decu" (...itd), samo "najmladja generacija" moze da bude ekskluzivno skrivena, ili da "porodicni fajl" sadrzi sve generacije, koje onda nisu medjusobno izolovane, makar se ne vide izvana.

... a onda je Bjarne Stroustrup-u verovatno puk'o film (i zbog drugih stvari), ...

[ Časlav Ilić @ 08.07.2005. 13:52 ] @

„Funkcija unutar funkcije“ može biti vrlo zgodna stvar za rekurzije. Često rekurzivnoj funkciji trebaju pomoćni argumenti (za prenos nekog stanja iz jednog u drugi poziv), zbog čega pored nje mora da se napiše još jedna pomoćna funkcija kao interfejs. Tako da završimo sa globalnom funkcijom koju nikada ne treba pozivati, što je, rekao bih, relativno ružno :)

Na primer, faktorijel sa repnom rekurzijom. U C-u:

Code:

int faktorijel (int n) {
    return faktorijel_r(1, n);
}

int faktorijel_r (int f, int n) {
    if (n > 1) return faktorijel_r(n * f, n - 1);
    else return f;
}

U Šemi:

Code:

(define (faktorijel n)
    (define (faktorijel_r f n)
        (if (> n 1) (faktorijel_r (* n f) (- n 1)) f))
    (faktorijel_r 1 n))

_{[Ovu poruku je menjao Časlav Ilić dana 08.07.2005. u 14:56 GMT+1]}

[ Goq @ 08.07.2005. 14:36 ] @

Razmotrimo situaciju da zelimo da se "faktorijalizacija" zavrsi nekim drugim brojem umesto kecom. Dolazimo do situacije da "bespotrebno" mucimo procesor prenoseci zeljenu varijablu kroz sve cikluse:

Code:

int faktorijel (int n) {
    int x=3;
    return faktorijel_r(1, n, x);
}

int faktorijel_r (int f, int n, int x) {
    if (n > x) return faktorijel_r(n * f, n - 1);
    else return f;
}

To je sustina problema, bespotrebno mucimo procesor (kakav apsurd, masine nemaju osecanja...:)). To se moze izleciti ili globalnim varijablama ili da nas bas bude briga za bespotrebni prenos jedne iste varijable...

[ jablan @ 08.07.2005. 15:07 ] @

Ja ne shvatam baš šta hoćeš da postigneš.

Ako ti je problem vidljivost promenljivih, napravi klasu sa privatnim atributom i on će biti vidljiv iz svih metoda te klase, a neće biti vidljiv spolja.

Imaš li konkretan primer?

_{[Ovu poruku je menjao jablan dana 08.07.2005. u 16:08 GMT+1]}

[ Goq @ 08.07.2005. 16:57 ] @

U redu je, znam da se problem moze resiti koriscenjem klasa. Samo me je zanimalo to da li se Delphi kod moze jednostavnije prevesti na C.

[ Dragi Tata @ 09.07.2005. 02:58 ] @

U C-u nema "ugnježdenih funkcija", ali ih ima npr u D-u:

http://www.digitalmars.com/d/

[ zvrba @ 09.07.2005. 06:50 ] @

Citat:

Dragi Tata: U C-u nema "ugnježdenih funkcija"

GCC to ima kao ekstenziju. Ali iskljucivo za C. Ugnijezdjene funkcije ne rade u C++-u.