Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/utility/functional/placeholders"

From cppreference.com
< cpp‎ | utility‎ | functional
(formatting)
m (., headers sorted, fmt)
 
(29 intermediate revisions by 15 users not shown)
Line 1: Line 1:
−
{{cpp/title|placeholders}}
+
{{cpp/title|n=placeholders::|_1|_2, ...|_N}}
−
{{cpp/utility/functional/sidebar}}
+
{{cpp/utility/functional/navbar}}
−
{{ddcl list begin}}
+
{{dcl begin}}
−
{{ddcl list header | functional}}
+
{{dcl header|functional}}
−
{{ddcl list item |
+
{{dcl|
−
namespace placeholders {
+
/*see below*/ _1;
−
    extern /*unspecified*/ _1;
+
/*see below*/ _2;
−
    extern /*unspecified*/ _2;
+
.
−
    .
+
.
−
    .
+
/*see below*/ _N;
−
    extern /*unspecified*/ _N;
+
}}
−
}
+
{{dcl end}}
 +
 
 +
The {{lc|std::placeholders}} namespace contains the placeholder objects {{tt|[_1, ..., _N]}} where {{tt|N}} is an implementation defined maximum number.
 +
 
 +
When used as an argument in a {{lc|std::bind}} expression, the placeholder objects are stored in the generated function object, and when that function object is invoked with unbound arguments, each placeholder {{tt|_N}} is replaced by the corresponding Nth unbound argument.
 +
 
 +
{{rev begin}}
 +
{{rev|until=c++17|
 +
Each placeholder is declared as if by {{c|extern /*unspecified*/ _1;}}.
 +
}}
 +
{{rev|since=c++17|
 +
Implementations are encouraged to declare the placeholders as if by {{c|inline constexpr /*unspecified*/ _1;}}, although declaring them by {{c|extern /*unspecified*/ _1;}} is still allowed by the standard.
 
}}
 
}}
−
{{ddcl list end}}
+
{{rev end}}
−
{{todo}}
+
The types of the placeholder objects are {{named req|DefaultConstructible}} and {{named req|CopyConstructible}}, their default copy/move constructors do not throw exceptions, and for any placeholder {{tt|_N}}, the type {{c|std::is_placeholder<decltype(_N)>}} is defined, where {{c|std::is_placeholder<decltype(_N)>}} is derived from {{c|std::integral_constant<int, N>}}.
−
The {{cpp|std::placeholders}} namespace contains the placeholder objects {{tt|[_1, . . . _N]}} where {{tt|N}} represents an implementation defined number for maximum replaceable function arguments.
+
  
 
===Example===
 
===Example===
−
{{example cpp
+
{{example
−
| The following code shows the creation of function objects with a placeholder argument.
+
|The following code shows the creation of function objects with placeholder arguments.
−
| code=
+
|code=
 
#include <functional>
 
#include <functional>
−
#include <string>
 
 
#include <iostream>
 
#include <iostream>
 +
#include <string>
  
 
void goodbye(const std::string& s)
 
void goodbye(const std::string& s)
Line 29: Line 39:
 
}
 
}
  
−
class Object {
+
class Object
 +
{
 
public:
 
public:
 
     void hello(const std::string& s)
 
     void hello(const std::string& s)
Line 37: Line 48:
 
};
 
};
  
−
int main(int argc, char* argv[])
+
int main()
 
{
 
{
−
     typedef std::function<void(const std::string&)> ExampleFunction;
+
     using namespace std::placeholders;
 +
 
 +
    using ExampleFunction = std::function<void(const std::string&)>;
 
     Object instance;
 
     Object instance;
 
     std::string str("World");
 
     std::string str("World");
−
     ExampleFunction f = std::bind(&Object::Hello, &instance, std::placeholders::_1);
+
 
−
      
+
     ExampleFunction f = std::bind(&Object::hello, &instance, _1);
−
    // equivalent to instance.hello(str)
+
     f(str); // equivalent to instance.hello(str)
−
    f(str);
+
 
 
     f = std::bind(&goodbye, std::placeholders::_1);
 
     f = std::bind(&goodbye, std::placeholders::_1);
−
 
+
     f(str); // equivalent to goodbye(str)
−
     // equivalent to goodbye(str)
+
 
−
     f(str);   
+
     auto lambda = [](std::string pre, char o, int rep, std::string post)
−
     return 0;
+
     {
 +
        std::cout << pre;
 +
        while (rep-- > 0)
 +
            std::cout << o;
 +
        std::cout << post << '\n';
 +
    };
 +
 
 +
    // binding the lambda:
 +
    std::function<void(std::string, char, int, std::string)> g =
 +
        std::bind(&decltype(lambda)::operator(), &lambda, _1, _2, _3, _4);
 +
    g("G", 'o', 'o'-'g', "gol");
 
}
 
}
−
| output=
+
|output=
 
Hello World
 
Hello World
 
Goodbye World
 
Goodbye World
 +
Goooooooogol
 
}}
 
}}
 +
 +
===See also===
 +
{{dsc begin}}
 +
{{dsc inc|cpp/utility/functional/dsc bind}}
 +
{{dsc inc|cpp/utility/functional/dsc is_placeholder}}
 +
{{dsc inc|cpp/utility/tuple/dsc ignore}}
 +
{{dsc end}}
 +
 +
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Latest revision as of 03:03, 25 May 2023

 
C++
 
Utilities library
General utilities
Relational operators (deprecated in C++20)
 
Function objects
Partial function application
(C++20)(C++23)
(C++11)
(C++11)
(C++11)
_1, _2, _3, ...
(C++11)
Function invocation
(C++17)(C++23)
Identity function object
(C++20)
Transparent operator wrappers
(C++14)
(C++14)
(C++14)
(C++14)  
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)

Old binders and adaptors
(until C++17*)
(until C++17*)
(until C++17*)
(until C++17*)
(until C++17*)  
(until C++17*)
(until C++17*)(until C++17*)(until C++17*)(until C++17*)
(until C++20*)
(until C++20*)
(until C++17*)(until C++17*)
(until C++17*)(until C++17*)

(until C++17*)
(until C++17*)(until C++17*)(until C++17*)(until C++17*)
(until C++20*)
(until C++20*)
 
Defined in header <functional>
/*see below*/ _1;

/*see below*/ _2;
.
.

/*see below*/ _N;

The std::placeholders namespace contains the placeholder objects [_1, ..., _N] where N is an implementation defined maximum number.

When used as an argument in a std::bind expression, the placeholder objects are stored in the generated function object, and when that function object is invoked with unbound arguments, each placeholder _N is replaced by the corresponding Nth unbound argument.

Each placeholder is declared as if by extern /*unspecified*/ _1;.

(until C++17)

Implementations are encouraged to declare the placeholders as if by inline constexpr /*unspecified*/ _1;, although declaring them by extern /*unspecified*/ _1; is still allowed by the standard.

(since C++17)

The types of the placeholder objects are DefaultConstructible and CopyConstructible, their default copy/move constructors do not throw exceptions, and for any placeholder _N, the type std::is_placeholder<decltype(_N)> is defined, where std::is_placeholder<decltype(_N)> is derived from std::integral_constant<int, N>.

[edit] Example

The following code shows the creation of function objects with placeholder arguments.

Run this code
#include <functional>
#include <iostream>
#include <string>
 
void goodbye(const std::string& s)
{
    std::cout << "Goodbye " << s << '\n';
}
 
class Object
{
public:
    void hello(const std::string& s)
    {
        std::cout << "Hello " << s << '\n';
    }
};
 
int main()
{
    using namespace std::placeholders;
 
    using ExampleFunction = std::function<void(const std::string&)>;
    Object instance;
    std::string str("World");
 
    ExampleFunction f = std::bind(&Object::hello, &instance, _1);
    f(str); // equivalent to instance.hello(str)
 
    f = std::bind(&goodbye, std::placeholders::_1);
    f(str); // equivalent to goodbye(str)
 
    auto lambda = [](std::string pre, char o, int rep, std::string post)
    {
        std::cout << pre;
        while (rep-- > 0)
            std::cout << o;
        std::cout << post << '\n';
    };
 
    // binding the lambda:
    std::function<void(std::string, char, int, std::string)> g =
        std::bind(&decltype(lambda)::operator(), &lambda, _1, _2, _3, _4);
    g("G", 'o', 'o'-'g', "gol");
}

Output: 

Hello World
Goodbye World
Goooooooogol

[edit] See also

(C++11)
 binds one or more arguments to a function object
(function template) [edit]
(C++11)
 indicates that an object is a standard placeholder or can be used as one
(class template) [edit]
(C++11)
 placeholder to skip an element when unpacking a tuple using tie
(constant) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/placeholders&oldid=152265"