| Ստանդարտ գրադարան C++ |
| --- |
| * Ներմուծում/արտածում
* Տողեր
 |
| Ստանդարտ կաղապարի գրադարան |
| * `algorithm`
* `functional`
* Հաջորդական կոնտեյներներ
* Ասոցիացված կոնտեյներներ
* Շեղ ասոցիացված կոնտեյներներ
 |
| Ստանդարտ գրադարան C |
| * Տվյալների տեսակներ
* Բնույթի դասակարգում
* Տողեր
* Մաթեմատիկա
* Ֆայլերի ներմուծում/արտածում
* Տվյալ/ժամանակ
* Լոկալիզացում
* Հիշողության տեղաբաշխում
* Գործընթացի վերահսկողություն
* Ազդանշան
* Այլընտրանքային կտրոններ

**Տարբեր վերնագրեր**:* `<assert.h>`
* `<errno.h>`
* `<setjmp.h>`
* `<stdarg.h>`
 |
| * դ
* ք
* խ
 |

**Functional**, C++, լեզվի Ստանդարտ գրադարանի վերնագրային ֆայլ, որը իրենից ներկայացնում է կաղապարների հավաքածու ֆունկցիոնալ օբյեկտների հետ աշխատելու համար, ինչպես նաև օգնական դասերի հավաքածու՝ ստանդարտ գրադարանի ալգորիթմներում օգտագործելու համար։

Պատմություն
-----------

Առաջին <functional> վերնագրային ֆայլն առաջացել է 1998 թվականին։ Ի սկզբանե նրա մեջ մտցրել են օժանդակ ֆունկցիոնալ օբյեկտներ, որպեսզի ավելի հեշտ օգտագործել STL։ Ինչպես նաև այստեղ են ներառվել կապողական (binders) և փաթաթողական ֆունկցիաներ, որոնց նպատակն էր հեշտացվել աշխատանքը, երբ ակտիվորեն օգտագործվում էր ցուցիչների փոխանցումը ֆունկցիաներին, այսինքն, երբ աշխատանք են կատարում ֆունկցիաների հետ։
Վերնագրային ֆայլերի Էական փոփոխություններ կատարվեց С++ TR1 ընդարձակման գրադարանում
։ Boost գրադարանից STL են տեղափոխել function, bind, mem\_fn, result\_of, reference\_wrapper, hash դասերը։ Այդ փոփոխությունների մեծամասնությունը, բացառությամբ result\_of-ի ընդգրկվեց այդ պահին օգտագործվող C++11 ստանդարտ լեզվի մեջ։ Քանի որ function-ը և bind-ը մեծ մասամբ կրկնօրինակում է 1998-ի ստանդարտի կապող ու փաթաթող ֆունկցիաներին, С++11-ում այդ ֆունկցիաները անվանված են հնացած (deprecated)։

Ընդհանուր հասկացություններ
--------------------------

### Ստանդարտի տերմինները

C++11 լեզվում օգտագործվում են <functional> վերնագրային ֆայլին վերաբերվող հետևյալ տերմինները՝

* **Ֆունկցիայի օբյեկտի տեսակ** (function object type)՝ փոստիֆիկ արտահայտություն ֆունկցիա կանչի ժամանակ, որտեղ փոստիֆիկ արտահայտությունը գերբեռնված ֆունկցիաների կամ կաղապարների կամ հասցեների հավաքածու է։
* **Զանգի ձև** (call signature) այս անվանումից հետո դրվում է Կլոր փակագծեր, որի մեջ գրվում է զրոների հերթականություն։
* **Կանչված տեսակ** (callable type)՝ ֆունկցիոնալ տիպի օբյեկտ կամ դասի անդամի ցուցիչ։
* **Կանչված օբյեկտ** (callable object) ՝ կանչված տեսակի օբյեկտ։
* **Կանչի օբյեկտի տեսակ** (call wrapper type) ` տիպ է, որը պարունակում է կանչվող օբյեկտ և աջակցում է կանչի գործողությանը, որը տանում է պահպանված օբյեկտի կանչին (invoke)։
* **Կանչի օբյեկտ** (call wrapper)՝ փաթաթող կանչ տեսակի օբյեկտ։
* **Նպատկի օբյեկտ** (target object)՝ կանչված օբյեկտ, որը պարունակում է կանչի օբյեկտ։

### Ֆունկցիոնալ օբյեկտի հասկացություն

Ֆունկցիոնալ օբյեկտը դաս է որոշակի կանչի ֆունկցիայի օպերատորով՝ operator ()։ Հետևյալ կոդի մեջ

```
FunctionObjectType func;
func();

```

func() արտահայտությունը համարվում է func ֆունկցիոնալ օբյեկտի կանչ, այլ ոչ թե որևէ ֆունկիայի կանչ, որի անունը func է։ Ֆունկցիոնալ օբյեկտի ձևը պետք է լինի հետևյալ կերպ՝

```
class FunctionObjectType {
 public:
 void operator() () {
 // Do some work
 }
};

```

Մինչև ֆունկցիայի օգտագործումը ֆունկցիոնալ օբյեկտները ունեն մի շարք առավելություններ։ Դրանցից են՝

1. Կարող է լինել երկու օբյեկտ նույն ֆունկցիոնալ տեսկի, բայց միևնույն ժամանակ գտնվեն տարբեր իրավիճակներում, որը հնարավոր չէ սովորական ֆունկցիաների ժամանակ։ Նաև ֆունկցիոնալ օբյեկտները կարող են տրամադրել նախնական տվյալների կարգավորման ծրագիր։
2. Յուրաքանչյուր ֆունկցիոնալ օբյեկտ ունի իր տեսակը, հետևաբար կա հնարավորություն փոխանցել այդ տեսակը որպես կաղապարի պարամետր, որպեսզի նշի որոշակի վարքագիծ։ Օրինակ՝ կոնտեյների տեսակները տարբեր ֆունկցիոնալ օբեյկներով տարբերվում են։
3. Օբյեկտ-ֆունկցիաները ավելի արագ են կատարվում քան ֆունկցիաների ցուցիչները։ Օրինակ՝ կառուցել (inline) դիմումը () դասի օպերատորին ավելի հեշտ քան ֆունկցիայի, որը փոխանցվել է ցուցչով։.

### Պրեդիկատներ

Ֆունկցիոնակ օբյեկտները, որոնք վերադարձնում են բուլյան տեսակ անվանում են *պրեդիկատներ*։ Ստանդարտ գրադարանում օգտագործում են ունար և բինար պրեդիկատներ։ Պրեդիկատի գործողությունները կախված չէ կատարվող գործողության պատճենման քանակից, քանի որ С++ ստանդարտը չի հաշվում, թե քանի անգամ է պատճենվել ալգորիթմը օգտագործման ժամանակ։

Փաթեթավորող գործառույթներ
-------------------------

### std::function

C++11 ստանդարտից սկսած std::function կաղապարային դասը համարվում է պոլիմորֆիզմ ֆունկցիայի փաթեթ ընդհանուր օգտագործման համար։ std::function դասի օբյեկտները կարող են պահել, պատճենել և կանչել կամայական *անհրաժեշտ օբյեկտներ* ՝ ֆունկցիա, լյամբդա-արտահայտություն և այլ ֆունկցիոնալ օբյեկտներ։ Ընդհանուր ասած, կամայական տեղ, որտեղ պետք է օգտագործել ֆունկցիայի ցուցիչը՝ կանչը չեղարկելու համար կամ հետ կանչի ֆունկցիա ստեղծելու համար օգտագործվում է std::function ֆունկցիան։

Առաջին անգամ տվյալ ֆունկցիան հայտնվել է Function գրադարանում Boost 1.23.0 տարբերակի ժամանակ։ Հետագա զարգացման ժամանակայն այն ներառվել է C++ TR1-ու և С++11-ում։

#### Դասի որոշումը

```
template<class> class function; // undefined
template<class R, class... ArgTypes> class function<R(ArgTypes...)>;

```

Ստանդարտում կան նաև օժանդակ բաղադրիչներ՝ swap и assign և համեմատության օպերատորներ՝ (== и !=), nullptr-ի հետ միասին։

#### Օգտագործման օրինակը

```
#include <iostream>
#include <functional>

struct A {
 A(int num) : num\_(num){}
 void printNumberLetter(char c) const {std::cout << "Number: "<< num\_ << "Letter: "<< c << std::endl;}
 int num\_;
};

void printLetter(char c)
{
 std::cout << c << std::endl;
}

struct B {
 void operator() () {std::cout << "B()" << std::endl;}
};

int main()
{
 // Ֆունկցիա
 std::function<void(char)> f\_print\_Letter = printLetter;
 f\_print\_Letter('Q');

 // Լյամբդա-արտահայտություն։
 std::function<void()> f\_print\_Hello = [] () {std::cout << "Hello world!" << std::endl;};
 f\_print\_Hello();

 // Կապիչ։
 std::function<void()> f\_print\_Z = std::bind(printLetter, 'Z');
 f\_print\_Z();

 // Դասի կանչ։
 std::function<void(const A&, char)> f\_printA = &A::printNumberLetter;
 A a(10);
 f\_printA(a, 'A');

 // Ֆունկցիոնալ օբյեկտ։
 B b;
 std::function<void()> f\_B = b;
 f\_B();
}

```

Վերևում գրված կոդի արդյունքը՝

```
Q
Hello world!
Z
Number: 10 Letter: A
B()

```

#### std::bad\_functional\_call

Բացառություն bad\_functional\_call տիպը կանտեսվի function::operator() ֆունցիայի փաթեթում թիրախի բացակայության դեպքում։ bad\_functional\_call ֆունկցիան եկել է std::exception ֆունկցիայից և նրա մեջ կա վիրտուալ what() տարբերակը տեքստի սխալը գտնելու համար։ Օգտագործման օրինակը՝

```
#include <iostream>
#include <functional>

int main()
{
 std::function<void()> func = nullptr;
 try {
 func();
 } catch(const std::bad\_function\_call& e) {
 std::cout << e.what() << std::endl;
 }
}

```

### std::mem\_fn

std::mem\_fn կաղապարային ֆունկցիան ստեղծում է փաթեթող օբյեկտ դասի անդամների շուրջը։ Այդ օբյեկտը կարող է պահել, պատճենել և կանչել դասի անդամին։.

Առաջին անգամ std::mem\_fn կաղապարային ֆունկցիան հայտնվել է Member Function գրադարանում (Boost 1.25.0 տարբերակով)։ Այն նույնպես ներառվել է C++ TR1-ում և С++11-ում։ Boost գրադարանում այն կատարելագործվում էր, որպես std::mem\_fun и std::mem\_fun\_ref ստանդարտ ֆունկցիաների ընդհանրացում։

Ֆունկցիոնալ օբյեկտներ
---------------------

Նախօրոք որոշված հիմնական հոդվածների համար նախատեսված ֆունկցիոնալ օբյեկտների հավաքածուն, կաղապարների ստանդարտ գրադարանի անբաժան մասն էր կազմում։ Նրանց մեջ մտնում էին թվաբանական գոծողություններ (+-\*/%), հիմնական տրամաբանական գործողությունները (&&, ||, !) և համեմատման գործողությունները (==, !=, >, <, >=, <=)։ Տրամաբանական և համեմատության գործողությունները համարվում են հաստատուններ և վերադարձնում են բուլյան տեսակը։ С++11-ից սկսած ավելացել են որոշ բիտային գործողություններ (and, or, xor, not)։

| տեսակ | անվանում | գործողությունների քանակ | վերադարձնող տեսակ | գործողություն |
| --- | --- | --- | --- | --- |
| Համեմատում | equal\_to | Բինար | bool | x == y  |
| not\_equal\_to | Բինար | bool | x != y |
| greater | Բինար | bool | x > y |
| less | Բինար | bool | x < y |
| greater\_equal | Բինար | bool | x >= y |
| less\_equal | Բինար | bool | x <= y |
| Логические | logical\_and | Բինար | bool | x && y |
| logical\_or | Բինար | bool | x || y |
| logical\_not | Ունար | bool | !x |
| Թվաբանական | plus | Բինար | T | x + y |
| minus | Բինար | T | x - y |
| multiplies | Բինար | T | x \* y |
| divides | Բինար | T | x / y |
| modulus | Բինար | T | x % y |
| negate | Ունար | T | -x |
| Բիտային (C++11) | bit\_and | Բինար | T | x & y |
| bit\_or | Բինար | T | x | y |
| bit\_xor | Բինար | T | x ^ y |
| bit\_not | Ունար | T | ~x |

Փաթեթների հղումներ
------------------

<functional> վերնագրային ֆայլում կա օգնող std::reference\_wrapper դաս, որն ինքնըստինքյան տալիս է օբյեկտի հղում կամ ֆունկցիայի հղում, որը փոխանցվել էր նրան կաղապարով։ reference\_wrapper ֆունկցիան իմաստը կայնում է նրանում, որ պահպանել հղումները, որը փոխանցվել էր T տեսակի կաղապներում և արտածել այն երբ դիմում ենք operator T& ()-ին։

Առաջին անգամ reference\_wrapper կաղապարային դասը հայտնվել է Ref գրադարանում (Boost 1.25.0 տարբերակի մեջ)։ որոշ բերելավումներից հետո նա ավելացվել է С++11 մեջ։

reference\_wrapper օբյեկտներ ստեղծելու համար տրված են օգնական ref և cref ֆունկցիաներ։ Որոշված են հետևյալ կերպ՝

```
template <class T> reference\_wrapper<T> ref(T& t) noexcept;
template <class T> reference\_wrapper<const T> cref(const T& t) noexcept;

```

Տես նաև
-------

* C++
* C++11
* C++ լեզվի ստանդարտ գրադարան

Ծանոթագրություններ
------------------

1. ↑  "Programming languages - C++" (in անգլերեն). ISO/IEC 14882. 1998 թ․ ապրիլի 23. Արխիվացված է the original 2013 թ․ մայիսի 17-ին. Retrieved 2013 թ․ մայիսի 1. `{{cite web}}`: Unknown parameter `|dead-url=` ignored (`|url-status=` suggested) (help)
2. 1 2  Alexander Stepanov and Meng Lee (1995 թ․ նոյեմբերի 14). "The Standard Template Library" (PDF) (in անգլերեն). HP Laboratories Technical Report 95-11(R.1). Արխիվացված է the original (PDF) 2013 թ․ մայիսի 17-ին. Retrieved 2013 թ․ մայիսի 1. `{{cite web}}`: Unknown parameter `|dead-url=` ignored (`|url-status=` suggested) (help)
3. ↑  
 (2005-06-24)։ «*Draft Technical Report on C++ Library Extensions*»։ ISO/IEC JTC1/SC22/WG21։  Վերցված՝ 2013-05-01։
4. 1 2  "ISO/IEC 14882:2011". ISO. 2011 թ․ սեպտեմբերի 2. Արխիվացված է the original 2013 թ․ մայիսի 17-ին. Retrieved 2013 թ․ մայիսի 2. `{{cite web}}`: Unknown parameter `|dead-url=` ignored (`|url-status=` suggested) (help)
5. ↑  Josuttis, Nicolai M. (2012). *The C++ standard library : a tutorial and reference*. Addison-Wesley. ISBN 0-321-62321-5.
6. ↑  
Stroustrup, Bjarne (2000). *The C++ Programming Language: Special Edition*. Addison-Wesley. ISBN 0-201-70073-5.
7. 1 2 3  "Boost Library Documentation" (in անգլերեն). Արխիվացված է the original 2013 թ․ մայիսի 17-ին. Retrieved 2013 թ․ մայիսի 1. `{{cite web}}`: Unknown parameter `|dead-url=` ignored (`|url-status=` suggested) (help)
8. ↑  "Boost Library Documentation : mem\_fn.hpp" (in անգլերեն). Արխիվացված է the original 2013 թ․ մայիսի 17-ին. Retrieved 2013 թ․ մայիսի 2. `{{cite web}}`: Unknown parameter `|dead-url=` ignored (`|url-status=` suggested) (help)