Lambda izteiksmes C ++

Lambda Expressions C



Kāpēc Lambda Expression?

Apsveriet šādu paziņojumu:

intmyInt= 52;

Šeit myInt ir identifikators, vērtība. 52 ir burtiski, prvalue. Mūsdienās ir iespējams īpaši kodēt funkciju un ievietot to pozīcijā 52. Šādu funkciju sauc par lambda izteiksmi. Apsveriet arī šādu īsu programmu:







#iekļaut

izmantojot vārda telpastundas;

intfn(intcauri)

{

intatbildi=cauri+ 3;

atgrieztiesatbildi;

}


intgalvenais()

{

fn(5);



atgriezties 0;

}

Mūsdienās ir iespējams īpaši kodēt funkciju un ievietot to 5 argumenta, funkcijas izsaukuma fn (5) pozīcijā. Šādu funkciju sauc par lambda izteiksmi. Lambda izteiksme (funkcija) šajā pozīcijā ir vērtība.



Jebkurš literālis, izņemot virkņu literālu, ir prvalue. Lambda izteiksme ir īpašs funkciju dizains, kas kodā iederētos burtiski. Tā ir anonīma (nenosaukta) funkcija. Šajā rakstā ir izskaidrota jaunā C ++ primārā izteiksme, ko sauc par lambda izteiksmi. Pamatzināšanas par C ++ ir prasība, lai saprastu šo rakstu.



Raksta saturs

Lambda izteiksmes ilustrācija

Šajā programmā funkcija, kas ir lambda izteiksme, tiek piešķirta mainīgajam:





#iekļaut

izmantojot vārda telpastundas;

autofn= [](intapstāties)

{

intatbildi=apstāties+ 3;

atgrieztiesatbildi;

};


intgalvenais()

{

automainīgais=fn(2);

izmaksas <<mainīgais<< ' n';


atgriezties 0;

}

Rezultāts ir šāds:

5

Ārpus galvenās () funkcijas ir mainīgais fn. Tās tips ir auto. Automātisks šajā situācijā nozīmē, ka faktisko tipu, piemēram, int vai float, nosaka piešķiršanas operatora pareizais operands (=). Piešķiršanas operatora labajā pusē ir lambda izteiksme. Lambda izteiksme ir funkcija bez iepriekšējā atgriešanās veida. Pievērsiet uzmanību kvadrātiekavu izmantošanai un novietojumam, []. Funkcija atgriež 5, int, kas noteiks fn veidu.



Galvenajā () funkcijā ir paziņojums:

automainīgais=fn(2);

Tas nozīmē, ka fn ārpus galvenā () beidzas kā funkcijas identifikators. Tās netiešie parametri ir lambda izteiksmes parametri. Mainīgā veids ir automātisks.

Ņemiet vērā, ka lambda izteiksme beidzas ar semikolu, tāpat kā klases vai struktūras definīcija beidzas ar semikolu.

Šajā programmā funkcija, kas ir lambda izteiksme, atgriež vērtību 5, ir arguments citai funkcijai:

#iekļaut

izmantojot vārda telpastundas;

spēkā neesošscitsfn(int1,int (*ptr)(int))

{

int2= (*ptr)(2);

izmaksas <<nē1<< '' <<2<< ' n';

}


intgalvenais()

{

citsfn(4,[](intapstāties)

{

intatbildi=apstāties+ 3;

atgrieztiesatbildi;

});


atgriezties 0;
}

Rezultāts ir šāds:

Četri, pieci

Šeit ir divas funkcijas - lambda izteiksme un funkcija otherfn (). Lambda izteiksme ir otrais arguments otherfn (), ko sauc par galveno (). Ņemiet vērā, ka lambda funkcija (izteiksme) šajā zvanā nebeidzas ar semikolu, jo šeit tas ir arguments (nevis atsevišķa funkcija).

Funkcijas lambda funkcijas otherfn () definīcijā ir rādītājs uz funkciju. Rādītājam ir nosaukums, ptr. Nosaukums ptr tiek izmantots definīcijā otherfn (), lai izsauktu lambda funkciju.

Paziņojums,

int2= (*ptr)(2);

Definīcijā otherfn () tas izsauc lambda funkciju ar argumentu 2. Zvanu atgriešanas vērtība '(*ptr) (2)' no lambda funkcijas tiek piešķirta no2.

Iepriekš minētā programma arī parāda, kā lambda funkciju var izmantot C ++ atzvanīšanas funkciju shēmā.

Lambda izteiksmes daļas

Tipiskas lambda funkcijas daļas ir šādas:

[] () {}
  • [] ir uztveršanas klauzula. Tajā var būt priekšmeti.
  • () ir parametru sarakstam.
  • {} ir funkcijas pamatteksts. Ja funkcija darbojas atsevišķi, tai jābeidzas ar semikolu.

Uzņem

Funkcijas lambda definīciju var piešķirt mainīgajam vai izmantot kā argumentu citam funkcijas izsaukumam. Šādas funkcijas izsaukuma definīcijai kā parametram jābūt rādītājam uz funkciju, kas atbilst lambda funkcijas definīcijai.

Lambda funkcijas definīcija atšķiras no parastās funkcijas definīcijas. To var piešķirt mainīgajam globālajā tvērumā; šo funkciju, kas piešķirta mainīgajam, var kodēt arī citas funkcijas ietvaros. Piešķirot globālajam darbības jomas mainīgajam, tā struktūra var redzēt citus globālās darbības jomas mainīgos. Piešķirot mainīgajam normālas funkcijas definīcijā, tā pamatteksts var redzēt citus mainīgos funkciju diapazonā tikai ar uztveršanas klauzulas palīdzību [].

Uztveršanas klauzula [], kas pazīstama arī kā lambda ievads, ļauj mainīgos nosūtīt no apkārtējās (funkcijas) darbības jomas lambda izteiksmes funkciju pamattekstā. Tiek teikts, ka lambda izteiksmes funkcijas ķermenis uztver mainīgo, kad tas saņem objektu. Bez uztveršanas klauzulas [] mainīgo nevar nosūtīt no apkārtējās darbības jomas lambda izteiksmes funkciju pamattekstā. Šī programma ilustrē to ar galveno () funkciju apjomu kā apkārtējo:

#iekļaut

izmantojot vārda telpastundas;

intgalvenais()

{

intid= 5;


autofn= [id]()

{

izmaksas <<id<< ' n';

};

fn();


atgriezties 0;

}

Izeja ir 5 . Bez nosaukuma, id, [] iekšpusē lambda izteiksme nebūtu redzējusi main (id) galvenās () funkcijas darbības jomas.

Notveršana pēc atsauces

Iepriekš minētais uztveršanas klauzulas izmantošanas veids ir tveršana pēc vērtības (skatiet informāciju zemāk). Uztverot ar atsauci, mainīgā lieluma atrašanās vieta (uzglabāšana), piemēram, apkārt esošā tvēruma ID, ir pieejama lambda funkcijas korpusā. Tātad, mainot mainīgā vērtību lambda funkcijas korpusā, mainīsies tā paša mainīgā vērtība apkārtējā tvērumā. Lai sasniegtu šo mērķi, pirms katra mainīgā, kas atkārtots uztveršanas klauzulā, ir zīme '&'. Šī programma to ilustrē:

#iekļaut

izmantojot vārda telpastundas;

intgalvenais()

{

intid= 5; peldētpēdas= 2.3; charch= 'TO';

autofn= [&id,&pēdas,&ch]()

{

id= 6;pēdas= 3.4;ch= “B”;

};

fn();

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ' n';

atgriezties 0;

}

Rezultāts ir šāds:

6., 3.4., B.

Apstiprinot, ka mainīgo nosaukumi lambda izteiksmes funkcijas pamattekstā attiecas uz tiem pašiem mainīgajiem ārpus lambda izteiksmes.

Notveršana pēc vērtības

Uztverot pēc vērtības, lambda funkcijas pamattekstā ir pieejama mainīgā atrašanās vietas kopija, apkārtējā tvērums. Lai gan mainīgais lambda funkcijas korpusā ir kopija, tā vērtību pagaidām nevar mainīt ķermeņa iekšienē. Lai panāktu notveršanu pēc vērtības, pirms katra mainīšanas, kas atkārtota uztveršanas klauzulā, nekas nav priekšā. Šī programma to ilustrē:

#iekļaut

izmantojot vārda telpastundas;

intgalvenais()

{

intid= 5; peldētpēdas= 2.3; charch= 'TO';

autofn= [id, ft, ch]()

{

// id = 6; pēdas = 3,4; ch = 'B';

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ' n';

};

fn();

id= 6;pēdas= 3.4;ch= “B”;

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ' n';

atgriezties 0;

}

Rezultāts ir šāds:

5., 2.3., A.

6., 3.4., B.

Ja komentāru indikators tiek noņemts, programma netiks apkopota. Kompilators izsniegs kļūdas ziņojumu, ka mainīgos mainīgās funkcijas pamatdaļas lambda izteiksmes definīcijā nevar mainīt. Lai gan mainīgos nevar mainīt lambda funkcijas iekšienē, tos var mainīt ārpus lambda funkcijas, kā redzams iepriekš minētās programmas iznākumā.

Uzņemšanas sajaukšana

Uzņemšanu ar atsauci un uztveršanu pēc vērtības var sajaukt, kā parādīta šajā programmā:

#iekļaut

izmantojot vārda telpastundas;

intgalvenais()

{

intid= 5; peldētpēdas= 2.3; charch= 'TO'; boolbl= taisnība;


autofn= [id, ft,&ch,&bl]()

{

ch= “B”;bl= nepatiesa;

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ',' <<bl<< ' n';

};

fn();


atgriezties 0;

}

Rezultāts ir šāds:

5., 2.3., B, 0

Kad visi ir uzņemti, ir atsauce:

Ja visi tverjamie mainīgie tiek uztverti ar atsauci, tad uztveršanas klauzulā pietiek ar vienu &. Šī programma to ilustrē:

#iekļaut

izmantojot vārda telpastundas;

intgalvenais()

{

intid= 5; peldētpēdas= 2.3; charch= 'TO'; boolbl= taisnība;


autofn= [&]()

{

id= 6;pēdas= 3.4;ch= “B”;bl= nepatiesa;

};

fn();

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ',' <<bl<< ' n';


atgriezties 0;

}

Rezultāts ir šāds:

6., 3.4., B, 0

Ja daži mainīgie ir jāreģistrē ar atsauci, bet citi pēc vērtības, tad viens & attēlo visas atsauces, bet pārējo priekšā nekas nav, kā parādīta šajā programmā:

izmantojot vārda telpastundas;

intgalvenais()

{

intid= 5; peldētpēdas= 2.3; charch= 'TO'; boolbl= taisnība;


autofn= [&, id, ft]()

{

ch= “B”;bl= nepatiesa;

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ',' <<bl<< ' n';

};

fn();


atgriezties 0;

}

Rezultāts ir šāds:

5., 2.3., B, 0

Ņemiet vērā, ka uztveršanas klauzulas pirmajai rakstzīmei ir jābūt tikai un vienīgi (t.i., un kam neseko identifikators).

Kad visi ir uzņemti, tie ir pēc vērtības:

Ja visi maināmie maināmie ir jāattver pēc vērtības, tad uztveršanas klauzulā pietiek ar vienu =. Šī programma to ilustrē:

#iekļaut

izmantojot vārda telpastundas;

intgalvenais()
{

intid= 5; peldētpēdas= 2.3; charch= 'TO'; boolbl= taisnība;


autofn= [=]()

{

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ',' <<bl<< ' n';

};

fn();


atgriezties 0;


}

Rezultāts ir šāds:

5., 2.3., A, 1

Piezīme : = pašlaik ir tikai lasāms.

Ja daži mainīgie ir jāfiksē pēc vērtības, bet citi ar atsauci, tad viens = attēlo visus tikai lasāmos mainīgos, un pārējiem katram ir &, kā parādīta šajā programmā:

#iekļaut

izmantojot vārda telpastundas;

intgalvenais()

{

intid= 5; peldētpēdas= 2.3; charch= 'TO'; boolbl= taisnība;


autofn= [=,&ch,&bl]()

{

ch= “B”;bl= nepatiesa;

izmaksas <<id<< ',' <<pēdas<< ',' <<ch<< ',' <<bl<< ' n';

};

fn();


atgriezties 0;

}

Rezultāts ir šāds:

5., 2.3., B, 0

Ņemiet vērā, ka = vienai ir jābūt pirmajai rakstzīmei uztveršanas klauzulā.

Klasiskā atzvanīšanas funkciju shēma ar Lambda izteiksmi

Šī programma parāda, kā klasisko atzvanīšanas funkciju shēmu var izdarīt ar lambda izteiksmi:

#iekļaut

izmantojot vārda telpastundas;

char *izvade;


autocba= [](charārā[])

{

izvade=ārā;

};



spēkā neesošsmainFunc(charievadi[],spēkā neesošs (*priekš)(char[]))

{

(*priekš)(ievadi);

izmaksas<<'galvenajai funkcijai'<<' n';

}


spēkā neesošsfn()

{

izmaksas<<'Tagad'<<' n';

}


intgalvenais()

{

charievadi[] = 'atzvanīšanas funkcijai';

mainFunc(ievade, cba);

fn();

izmaksas<<izvade<<' n';



atgriezties 0;

}

Rezultāts ir šāds:

galvenajai funkcijai

Tagad

atzvanīšanas funkcijai

Atgādiniet, ka tad, kad lambda izteiksmes definīcija ir piešķirta mainīgajam globālajā tvērumā, tās funkciju struktūra var redzēt globālos mainīgos, neizmantojot uztveršanas klauzulu.

Trailing-return-tips

Lambda izteiksmes atgriešanas veids ir automātisks, kas nozīmē, ka kompilators nosaka atgriešanās veidu no atgriešanās izteiksmes (ja tāda ir). Ja programmētājs patiešām vēlas norādīt atgriešanas veidu, viņš to darīs tāpat kā šajā programmā:

#iekļaut

izmantojot vārda telpastundas;

autofn= [](intapstāties) -> int

{

intatbildi=apstāties+ 3;

atgrieztiesatbildi;

};


intgalvenais()

{

automainīgais=fn(2);

izmaksas <<mainīgais<< ' n';


atgriezties 0;

}

Rezultāts ir 5. Pēc parametru saraksta tiek ierakstīts bultiņu operators. Tam seko atgriešanās veids (šajā gadījumā int).

Slēgšana

Apsveriet šādu koda segmentu:

struktūraCla

{

intid= 5;

charch= 'uz';

}obj1, obj2;

Šeit Cla ir strukturālās klases nosaukums. Obj1 un obj2 ir divi objekti, kas tiks eksponēti no struktūras klases. Lambda izteiksme īstenošanā ir līdzīga. Lambda funkcijas definīcija ir sava veida klase. Kad tiek izsaukta (izsaukta) lambda funkcija, objekts tiek parādīts no tā definīcijas. Šo objektu sauc par slēgšanu. Tieši slēgšana veic darbu, ko lambda gaida.

Tomēr, kodējot lambda izteiksmi, piemēram, iepriekš minēto struktūru, obj1 un obj2 tiks aizstāti ar atbilstošo parametru argumentiem. Šī programma to ilustrē:

#iekļaut

izmantojot vārda telpastundas;

autofn= [](intparam1,intparam2)

{

intatbildi=param1+param2;

atgrieztiesatbildi;

} (2,3);


intgalvenais()

{

autokur=fn;

izmaksas <<kur<< ' n';


atgriezties 0;

}

Rezultāts ir 5. Argumenti iekavās ir 2 un 3. Ņemiet vērā, ka lambda izteiksmes funkcijas izsaukums fn neņem vērā nevienu argumentu, jo argumenti jau ir kodēti lambda funkcijas definīcijas beigās.

Secinājums

Lambda izteiksme ir anonīma funkcija. Tas sastāv no divām daļām: klases un objekta. Tās definīcija ir sava veida klase. Izsaucot izteiksmi, no definīcijas tiek veidots objekts. Šo objektu sauc par slēgšanu. Tieši slēgšana veic darbu, ko lambda gaida.

Lai lambda izteiksme saņemtu mainīgo no ārējās funkcijas darbības jomas, tās pamattekstā ir nepieciešama ne tukša uztveršanas klauzula.