C++20 рдорд╛рдирдХ рд╕реНрд╡реАрдХреГрдд

C++ рднрд╛рд╖рд╛рдХреЛ рдорд╛рдирдХреАрдХрд░рдгрдорд╛ ISO рд╕рдорд┐рддрд┐ рд╕реНрд╡реАрдХреГрдд рдЕрдиреНрддрд░реНрд░рд╛рд╖реНрдЯреНрд░рд┐рдп рдорд╛рдкрджрдгреНрдб"C ++ рез"ред рд╕реНрдкреЗрд╕рд┐рдлрд┐рдХреЗрд╢рдирдорд╛ рдкреНрд░рд╕реНрддреБрдд рдЧрд░рд┐рдПрдХрд╛ рдХреНрд╖рдорддрд╛рд╣рд░реВ, рдкреГрдердХ рдХреЗрд╕рд╣рд░реВ рдмрд╛рд╣реЗрдХ, рд╕рдорд░реНрдерд┐рдд рдХрдореНрдкрд╛рдЗрд▓рд░рд╣рд░реВрдорд╛ рдЬреАрд╕реАрд╕реА, рдЭрдиреНрдЭрдЯ ╨╕ рдорд╛рдЗрдХреНрд░реЛрд╕рдлреНрдЯ рднрд┐рдЬреБрдЕрд▓ рд╕реА ++ред C++20 рд▓рд╛рдИ рд╕рдорд░реНрдерди рдЧрд░реНрдиреЗ рдорд╛рдирдХ рдкреБрд╕реНрддрдХрд╛рд▓рдпрд╣рд░реВ рдкрд░рд┐рдпреЛрдЬрдирд╛ рднрд┐рддреНрд░ рд▓рд╛рдЧреВ рдЧрд░рд┐рдПрдХреЛ рдЫ рдмрдврд╛рд╡рд╛.

рдЖрдЧрд╛рдореА рджреБрдИ рдорд╣рд┐рдирд╛рдорд╛, рд╕реНрд╡реАрдХреГрдд рд╕реНрдкреЗрд╕рд┐рдлрд┐рдХреЗрд╢рди рдкреНрд░рдХрд╛рд╢рдирдХреЛ рд▓рд╛рдЧрд┐ рдХрд╛рдЧрдЬрд╛рдд рддрдпрд╛рд░ рдЧрд░реНрдиреЗ рдЪрд░рдгрдорд╛ рд╣реБрдиреЗрдЫ, рдЬрд╕рдорд╛ рд╣рд┐рдЬреНрдЬреЗ рддреНрд░реБрдЯрд┐ рд░ рдЯрд╛рдЗрдкрдХреЛ рд╕рдореНрдкрд╛рджрдХреАрдп рд╕реБрдзрд╛рд░ рдЧрд░реНрдиреЗ рдХрд╛рдо рдЧрд░рд┐рдиреЗрдЫред рдиреЛрднреЗрдореНрдмрд░рдХреЛ рд╕реБрд░реБрдорд╛, рдирддрд┐рдЬрд╛ рдХрд╛рдЧрдЬрд╛рддрд▓рд╛рдИ ISO/IEC 14882:2020 рдФрдкрдЪрд╛рд░рд┐рдХ рдирд╛рдо рдЕрдиреНрддрд░реНрдЧрдд рдкреНрд░рдХрд╛рд╢рдирдХреЛ рд▓рд╛рдЧрд┐ ISO рдорд╛ рдкрдард╛рдЗрдиреЗрдЫред рдпрд╕ рдмреАрдЪрдорд╛, рд╕рдорд┐рддрд┐рд▓реЗ рдЕрд░реНрдХреЛ C++23 рдорд╛рдкрджрдгреНрдб (C++2b) рдорд╛ рдХрд╛рдо рд╕реБрд░реБ рдЧрд░рд┐рд╕рдХреЗрдХреЛ рдЫ рд░ рдЕрд░реНрдХреЛ рднрд░реНрдЪреБрдЕрд▓ рдмреИрдардХрдорд╛ рд╕рдореНрднрд╛рд╡рд┐рдд рд╡рд┐рдХрд▓реНрдкрд╣рд░реВ рд╡рд┐рдЪрд╛рд░ рдЧрд░реНрдиреЗрдЫред рдирд╡рд╛рдЪрд╛рд░рд╣рд░реВ.

рдореБрдЦреНрдп рд╡рд┐рд╢реЗрд╖рддрд╛рд╣рд░реБ C ++ рез (рдХреЛрдб рдЙрджрд╛рд╣рд░рдгрд╣рд░реВ):

  • рдердкрд┐рдпреЛ "рдЕрд╡рдзрд╛рд░рдгрд╛рд╣рд░реВ", рдЯреЗрдореНрдкреНрд▓реЗрдЯ рд╡рд┐рд╕реНрддрд╛рд░рд╣рд░реВ, рдЬрд╕рд▓реЗ рддрдкрд╛рдИрдВрд▓рд╛рдИ рдЯреЗрдореНрдкреНрд▓реЗрдЯ рдкреНрдпрд╛рд░рд╛рдорд┐рдЯрд░ рдЖрд╡рд╢реНрдпрдХрддрд╛рд╣рд░реВрдХреЛ рд╕реЗрдЯ рдкрд░рд┐рднрд╛рд╖рд┐рдд рдЧрд░реНрди рдЕрдиреБрдорддрд┐ рджрд┐рдиреНрдЫ рдЬрд╕рд▓реЗ, рдХрдореНрдкрд╛рдЗрд▓ рд╕рдордпрдорд╛, рдЯреЗрдореНрдкреНрд▓реЗрдЯ рдкреНрдпрд╛рд░рд╛рдорд┐рдЯрд░рд╣рд░реВрдХреЛ рд░реВрдкрдорд╛ рд╕реНрд╡реАрдХрд╛рд░ рдЧрд░реНрди рд╕рдХрд┐рдиреЗ рддрд░реНрдХрд╣рд░реВрдХреЛ рд╕реЗрдЯрд▓рд╛рдИ рд╕реАрдорд┐рдд рдЧрд░реНрджрдЫред рдЯреЗрдореНрдкреНрд▓реЗрдЯ рднрд┐рддреНрд░ рдкреНрд░рдпреЛрдЧ рдЧрд░рд┐рдПрдХрд╛ рдбрд╛рдЯрд╛ рдкреНрд░рдХрд╛рд░рдХрд╛ рдЧреБрдгрд╣рд░реВ рд░ рдЗрдирдкреБрдЯ рдкреНрдпрд╛рд░рд╛рдорд┐рдЯрд░рд╣рд░реВрдХреЛ рдбрд╛рдЯрд╛ рдкреНрд░рдХрд╛рд░ рдЧреБрдгрд╣рд░реВ рдмреАрдЪрдХреЛ рддрд╛рд░реНрдХрд┐рдХ рдЕрд╕рдВрдЧрддрд┐рдмрд╛рдЯ рдмрдЪреНрди рдЕрд╡рдзрд╛рд░рдгрд╛рд╣рд░реВ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрди рд╕рдХрд┐рдиреНрдЫред

    рдЯреЗрдореНрдкреНрд▓реЗрдЯ
    рдЕрд╡рдзрд╛рд░рдгрд╛ EqualityComparable = рдЖрд╡рд╢реНрдпрдХ рдЫ (T a, T b) {
    { a == b } -> std:: boolean;
    { a != b } -> std::boolean;
    };

  • рд╕реНрд╡реАрдХрд╛рд░ рдЧрд░рд┐рдпреЛ рд╡рд┐рд╕реНрддрд╛рд░ рд╣реЗрдбрд░ рдлрд╛рдЗрд▓рд╣рд░реВрдХреЛ рд╕рдЯреНрдЯрд╛ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрди рд╕рдХрд┐рдиреЗ рдореЛрдбреНрдпреБрд▓рд╣рд░реВрд╕рдБрдЧ рдХрд╛рдо рдЧрд░реНрдирдХрд╛ рд▓рд╛рдЧрд┐ред рдореЛрдбреНрдпреБрд▓рд╣рд░реВрд▓реЗ "#include" рдорд╛рд░реНрдлрдд рд╣реЗрдбрд░ рдлрд╛рдЗрд▓рд╣рд░реВ рд╕рдорд╛рд╡реЗрд╢ рдирдЧрд░рд┐рдХрди рдХрдореНрдкреЛрдиреЗрдиреНрдЯрд╣рд░реВрдХреЛ рд╕реАрдорд╛рд╣рд░реВ рдкрд░рд┐рднрд╛рд╖рд┐рдд рдЧрд░реНрдиреЗ рдЖрдзрд╛рд░рдорд╛ рд╕реНрд░реЛрдд рдХреЛрдб рд╡реНрдпрд╡рд╕реНрдерд┐рдд рдЧрд░реНрди рдирдпрд╛рдБ рддрд░рд┐рдХрд╛ рдкреНрд░рджрд╛рди рдЧрд░реНрджрдЫред
  • рдореНрдпрд╛рдХреНрд░реЛ __VA_OPT__ рдЪрд░ рдЖрд░реНрдЧреБрдореЗрдиреНрдЯрдорд╛ рдЯреЛрдХрдирд╣рд░реВрдХреЛ рдЙрдкрд╕реНрдерд┐рддрд┐рдорд╛ рдирд┐рд░реНрднрд░ рднреНрдпрд╛рд░рд┐рдПрдмрд▓ рдореНрдпрд╛рдХреНрд░реЛрд╣рд░реВрдХреЛ рдЕрдиреБрдХреВрд▓рди рд╡рд┐рд╕реНрддрд╛рд░рдХреЛ рд▓рд╛рдЧрд┐ред
  • рддреАрди-рддрд░реНрдлреА рддреБрд▓рдирд╛рдХреЛ рд▓рд╛рдЧрд┐ "" рдЕрдкрд░реЗрдЯрд░рдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдердиред
  • рдмрд┐рдЯрдлрд┐рд▓реНрдбрд╣рд░реВрдХреЛ рд▓рд╛рдЧрд┐ рдкреВрд░реНрд╡рдирд┐рд░реНрдзрд╛рд░рд┐рдд рддрддреНрд╡ рдкреНрд░рд╛рд░рдореНрднрд┐рдХрд╣рд░реВрдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдердиред
  • Lambda "* рдпреЛ" рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐рд╣рд░реВ рдХреНрдпрд╛рдкреНрдЪрд░ рдЧрд░реНрдиреЗ рдХреНрд╖рдорддрд╛ред

    рд╕рдВрд░рдЪрдирд╛ int_value {
    int n = 0;
    auto getter_fn() {
    //рдЦрд░рд╛рдм:
    // рдлрд┐рд░реНрддрд╛ [=]() { рдлрд┐рд░реНрддрд╛ n; };

    // рд░рд╛рдореНрд░реЛ:
    рд░рд┐рдЯрд░реНрди [=, *this]() { рд░рд┐рдЯрд░реНрди n; };
    }
    };

  • "const &" рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐ рдорд╛рд░реНрдлрдд рдкрд░рд┐рднрд╛рд╖рд┐рдд рдЕрд╕реНрдерд╛рдпреА рд╡рд╕реНрддреБрд╣рд░реВрдорд╛ рд╕реВрдЪрдХрд╣рд░реВ рдкреНрд░рдпреЛрдЧ рдЧрд░реЗрд░ рд╕реВрдЪрдХ (рд╕рджрд╕реНрдп-рдмрд╛рдЯ-рд╕рджрд╕реНрдп) рджреНрд╡рд╛рд░рд╛ рддрддреНрд╡рд╣рд░реВрд▓рд╛рдИ рдХрд▓ рдЧрд░реНрджреИред
  • рдХрд╛рдЧрдЬрд╛рддрдорд╛ рд╡рд░реНрдгрди рдЧрд░рд┐рдПрдХреЛ рд╡рд┐рдирд╛рд╢рдХрд╕рдБрдЧ рдореЗрдЯрд╛рдЙрдиреЗ рдЕрдкрд░реЗрдЯрд░ P0722R1.
  • рд╡рд░реНрдЧрд╣рд░реВрд▓рд╛рдИ рдкреНрд░рдХрд╛рд░ рдмрд┐рдирд╛ рдЯреЗрдореНрдкреНрд▓реЗрдЯ рдкреНрдпрд╛рд░рд╛рдорд┐рдЯрд░рд╣рд░реВ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрди рдЕрдиреБрдорддрд┐ рджрд┐рдЗрдПрдХреЛ рдЫред

    рд╕рдВрд░рдЪрдирд╛ foo {
    foo() = рдкреВрд░реНрд╡рдирд┐рд░реНрдзрд╛рд░рд┐рдд;
    constexpr foo(int) {}
    };

    рдЯреЗрдореНрдкреНрд▓реЗрдЯ
    рд╕реНрд╡рддрдГ get_foo() {
    рдлрд┐рд░реНрддрд╛ f;
    }

    get_foo(); // рдирд┐рд╣рд┐рдд рдХрдиреНрд╕реНрдЯреНрд░рдХреНрдЯрд░ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрджрдЫ
    get_foo ();

  • рдХрдиреНрд╕реНрдЯреНрд░рдХреНрдЯрд░рд╕рдБрдЧ рдЧреИрд░-рдирд┐рд░рдиреНрддрд░ lambda рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐ред
  • lambda рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐рдХрд╛ рд▓рд╛рдЧрд┐ рдЯреЗрдореНрдкреНрд▓реЗрдЯ рд╡рд╛рдХреНрдп рд░рдЪрдирд╛рд▓рд╛рдИ рдЕрдиреБрдорддрд┐ рджрд┐рдБрджреИ (тАЬрд╕реНрд╡рдд: f = [] (std:: рднреЗрдХреНрдЯрд░ v)")ред
  • рдЯреЗрдореНрдкреНрд▓реЗрдЯ рдкреНрдпрд╛рд░рд╛рдорд┐рдЯрд░рд╣рд░реВрдорд╛ рд╕реНрдЯреНрд░рд┐рдЩ рд▓рд┐рдЯрд░рд▓рд╣рд░реВ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрдиреЗ рдХреНрд╖рдорддрд╛ред
  • C-рд╢реИрд▓реА рдкреНрд░рд╛рд░рдореНрднрд┐рдХ рд╡рд╛рдХреНрдпрд╡рд┐рдиреНрдпрд╛рд╕рдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдерди - рдкреНрд░рд╛рд░рдореНрднрд┐рдХ рд╕реВрдЪреАрдорд╛ рд╕реНрдкрд╖реНрдЯ рд░реВрдкрдорд╛ рд╕реВрдЪреАрдмрджреНрдз рдирдЧрд░рд┐рдПрдХрд╛ рдХреНрд╖реЗрддреНрд░рд╣рд░реВ рдкреВрд░реНрд╡рдирд┐рд░реНрдзрд╛рд░рд┐рдд рд░реВрдкрдорд╛ рдкреНрд░рд╛рд░рдореНрдн рдЧрд░рд┐рдПрдХрд╛ рдЫрдиреНред

    рд╕рдВрд░рдЪрдирд╛ рдП {
    рдИрдиреНрдЯ рдПрдХреНрд╕;
    int y;
    int z = 123;
    };

    A a {.x = 1, .z = 2}; // ax == 1, ay == 0, az == 2

  • рдЦрд╛рд▓реА рдбрд╛рдЯрд╛ рд╕рдВрд░рдЪрдирд╛ рд╕рджрд╕реНрдпрд╣рд░реВрдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдердиред
  • рд╕рдореНрднрд╛рд╡рд┐рдд рд░ рдЕрд╕рдореНрднрд╡ рд╡рд┐рд╢реЗрд╖рддрд╛рд╣рд░реВрдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдерди рд╕рд╢рд░реНрдд рдирд┐рд░реНрдорд╛рдг рдЯреНрд░рд┐рдЧрд░ рд╣реБрдиреЗ рд╕рдореНрднрд╛рд╡рдирд╛рдХреЛ рдмрд╛рд░реЗрдорд╛ рдЕрдкреНрдЯрд┐рдорд╛рдЗрдЬрд░рд▓рд╛рдИ рд╕реВрдЪрд┐рдд рдЧрд░реНрди (тАЬ[[рд╕рдореНрднрд╡]] рдпрджрд┐ (рдЕрдирд┐рдпрдорд┐рдд > 0) {тАЬ)ред
  • "рдХрд╛ рд▓рд╛рдЧрд┐" рд▓реБрдкрдорд╛ рдЪрд░ рдорд╛рдирд╣рд░реВ рдкреНрд░рд╛рд░рдореНрдн рдЧрд░реНрди рджрд╛рдпрд░рд╛рд╣рд░реВ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрдиреЗ рдХреНрд╖рдорддрд╛

    (auto v = std::vector{1, 2, 3}; auto&e : v) {

  • рдирдпрд╛рдБ ("рдирдпрд╛рдБ рдбрдмрд▓[]{1,2,3}") рдорд╛ рдПрд░реЗ рд╕рд╛рдЗрдЬрдХреЛ рд╕реНрд╡рдЪрд╛рд▓рд┐рдд рдЧрдгрдирд╛;
  • "[[no_unique_address]]" рд╡рд┐рд╢реЗрд╖рддрд╛ рдЬрд╕рдорд╛ рдбрд╛рдЯрд╛ рдмрд┐рдирд╛ рдЪрд▓рд╣рд░реВрд▓реЗ рдард╛рдЙрдБ рд▓рд┐рдБрджреИрдиред
  • рдкрд░рдорд╛рдгреБ рд╕реВрдЪрдХ (std::atomic > рд░ std::atomic >)
  • рд╕рд╢рд░реНрдд рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐рд╣рд░реВрдорд╛ рднрд░реНрдЪреБрдЕрд▓ рдкреНрд░рдХрд╛рд░реНрдпрд╣рд░реВ рдХрд▓ рдЧрд░реНрдиреЗ рдХреНрд╖рдорддрд╛ред
  • рддрддреНрдХрд╛рд▓ рдХрд╛рд░реНрдпрд╣рд░реВрдХрд╛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдерди рдЬрд╕рд▓реЗ рд╕реНрдерд┐рд░рддрд╛рд╣рд░реВрд╕рдБрдЧ рдорд╛рддреНрд░ рдХрд╛рдо рдЧрд░реНрди рд╕рдХреНрдЫред

    consteval int sqr(int n) {
    рдлрд┐рд░реНрддрд╛ n * n;
    }

    constexpr int r = sqr(100); // рдард┐рдХ рдЫ
    int x = 100;
    int r2 = sqr(x); // рддреНрд░реБрдЯрд┐: 'x' рдПрдХ рд╕реНрдерд┐рд░ рд░реВрдкрдорд╛ рдкреНрд░рдпреЛрдЧ рдЧрд░реНрди рд╕рдХрд┐рдБрджреИрди

  • рднрд░реНрдЪреБрдЕрд▓ рдкреНрд░рдХрд╛рд░реНрдпрд╣рд░реВрд╕рдБрдЧ constexpr рдкреНрд░рдпреЛрдЧ рдЧрд░реНрдиреЗ рд╕рдореНрднрд╛рд╡рдирд╛ ("constexpr рднрд░реНрдЪреБрдЕрд▓ int f() const { return 2; }")ред
  • рдорд╛рдирдХ рдкреБрд╕реНрддрдХрд╛рд▓рдпрдорд╛:
    • UTF-8 рд╕реНрдЯреНрд░рд┐рдЩрдХрд╛ рд▓рд╛рдЧрд┐ char8_t рдкреНрд░рдХрд╛рд░рдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдерди рдердкрд┐рдпреЛред
    • рд╣реЗрдбрд░ рдлрд╛рдЗрд▓рд╣рд░реВ рдмрд┐рдЯ (рдмрд┐рдЯ рдЕрдкрд░реЗрд╕рдирд╣рд░реВ) рд░ рд╕рдВрд╕реНрдХрд░рдг рдердкрд┐рдпреЛред
    • рдпреЛ рдЕрдм рд╕реНрдЯреНрд░рд┐рдЩрдХреЛ рдЙрдкрд╕рд░реНрдЧ рд░ рдкреНрд░рддреНрдпрдп рдЬрд╛рдБрдЪ рдЧрд░реНрди рд╕рдореНрднрд╡ рдЫ (starts_with, ends_with)ред
    • std::remove_cvref, std::unwrap_reference, std::unwrap_decay_ref, std::is_nothrow_convertible рд░ std::type_identity рд╡рд┐рд╢реЗрд╖рддрд╛рд╣рд░реВ рдердкрд┐рдпреЛред
    • std::midpoint, std::lerp, std::bind_front, std::source_location, std::visit, std::is_constant_evaluated рд░ std::assume_aligned рдкреНрд░рдХрд╛рд░реНрдпрд╣рд░реВ рдердкрд┐рдпреЛред
    • std::make_shared рдорд╛ arrays рдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдерди рдердкрд┐рдпреЛред
    • array-like рд╡рд╕реНрддреБрд╣рд░реВрд▓рд╛рдИ std::array рдорд╛ рд░реВрдкрд╛рдиреНрддрд░рдг рдЧрд░реНрди std::to_array рдкреНрд░рдХрд╛рд░реНрдп рдердкрд┐рдпреЛред
  • рдердк рд╕реБрд╡рд┐рдзрд╛рдЬрдирдХ рдЧрдгрдирд╛ рд╡рд╛рдХреНрдп рд░рдЪрдирд╛:

    enum рд╡рд░реНрдЧ rgba_color_channel { рд░рд╛рддреЛ, рд╣рд░рд┐рдпреЛ, рдиреАрд▓реЛ, рдЕрд▓реНрдлрд╛ };

    std::string_view to_string(rgba_color_channel my_channel) {
    рд╕реНрд╡рд┐рдЪ (my_channel) {
    enum rgba_color_channel рдкреНрд░рдпреЛрдЧ рдЧрд░реНрджреИ;
    рдХреЗрд╕ рд░рд╛рддреЛ: рдлрд┐рд░реНрддрд╛ "рд░рд╛рддреЛ";
    рдХреЗрд╕ рд╣рд░рд┐рдпреЛ: рдлрд┐рд░реНрддрд╛ "рд╣рд░рд┐рдпреЛ";
    рдХреЗрд╕ рдиреАрд▓реЛ: рдлрд┐рд░реНрддрд╛ "рдиреАрд▓реЛ";
    рдХреЗрд╕ рдЕрд▓реНрдлрд╛: рдлрд┐рд░реНрддрд╛ "рдЕрд▓реНрдлрд╛";
    }
    }

  • рдЕрдиреБрдХреНрд░рдордгрд┐рдХрд╛рд╣рд░реВрдорд╛, рдЕрдкрд░рд┐рднрд╛рд╖рд┐рдд рд╡реНрдпрд╡рд╣рд╛рд░рдХреЛ рдХрд╛рд░рдг, рдЕрдкрд░реЗрд╢рди "," ("a[b,c]") рдХреЛ рдкреНрд░рдпреЛрдЧ рдирд┐рд╖реЗрдз рдЧрд░рд┐рдПрдХреЛ рдЫред рд╡рд╛рд╖реНрдкрд╢реАрд▓ рдХреБрдЮреНрдЬреА рд╢рд╡реНрджрдХреЛ рд╕рд╛рде рдШреЛрд╖рд┐рдд рднреНрдпрд╛рд░реАрдПрдмрд▓рдХрд╛ рд╕рд╛рде рдЕрдзрд┐рдХрд╛рдВрд╢ рдЕрдкрд░реЗрд╢рдирд╣рд░реВрдХреЛ рд▓рд╛рдЧрд┐ рд╕рдорд░реНрдерди рдмрдиреНрдж рдЧрд░рд┐рдПрдХреЛ рдЫ, рдорд╛рдирдХ рдкреНрд░рдХрд╛рд░рдХрд╛ рд╕рд╛рде "++" рд░ "тАФ" рдЕрдкрд░реЗрд╕рдирд╣рд░реВ рд╕рд╣рд┐рддред
  • рдкреНрд░рдХрд╛рд░рдХреЛ рдЙрдкрд╕реНрдерд┐рддрд┐ рд╕рдВрдХреЗрдд рдЧрд░реНрди "рдЯрд╛рдЗрдкрдирд╛рдо" рдЖрд╡рд╢реНрдпрдХ рдкрд░реНрдиреЗ рдЕрд╡рд╕реНрдерд╛рд╣рд░реВрдХреЛ рд╕рдВрдЦреНрдпрд╛ рдШрдЯрд╛рдЗрдпреЛред

рд╕реНрд░реЛрдд: opennet.ru

рдПрдХ рдЯрд┐рдкреНрдкрдгреА рдердкреНрди