Using lambdas with the STL - Revision history

Jimg at 16:50, 16 October 2023

2023-10-16T16:50:24Z

← Older revision		Revision as of 16:50, 16 October 2023
Line 1:		Line 1:
	= Using lambdas with the STL =		= Using lambdas with the STL =

	Let;'s say you want to find the first instance of the variable named 'name' in one of our containers. The thing in the container is not a string, but a complex object with lots of fields, one of which happens to be a string that holds the name of the object. Here's the old, pre-c++-11 way using a function that returns a boolean and some adapters like bind2nd() and ptr_fun().		Let's say you want to find the first instance of the variable named 'name' in one of our containers. The thing in the container is not a string, but a complex object with lots of fields, one of which happens to be a string that holds the name of the object. Here's the old, pre-c++-11 way using a function that returns a boolean and some adapters like bind2nd() and ptr_fun().

	Change code like:		Change code like:

Jimg: /* Using lambdas with the STL */

2022-08-30T17:13:46Z

Using lambdas with the STL

← Older revision		Revision as of 17:13, 30 August 2022
Line 1:		Line 1:
	= Using lambdas with the STL =		= Using lambdas with the STL =

			Let;'s say you want to find the first instance of the variable named 'name' in one of our containers. The thing in the container is not a string, but a complex object with lots of fields, one of which happens to be a string that holds the name of the object. Here's the old, pre-c++-11 way using a function that returns a boolean and some adapters like bind2nd() and ptr_fun().

	Change code like:		Change code like:
Line 17:		Line 19:
	to:		to:
	<pre>		<pre>
	auto g = find_if(grp_begin(), grp_end(), [~~grp_name~~](const D4Group *g) { return g->name() == ~~grp_name~~; });		auto g = find_if(grp_begin(), grp_end(), [name](const D4Group *g) { return g->name() == name; });
	^ ^ ^		^ ^ ^
	1 2 3		1 2 3
	</pre>		</pre>

	Where ''[~~grp_name~~](const D4Group *g) { return g->name() == ~~grp_name~~; }'' is a C++ Lambda function (anonymous function).		Where ''[name](const D4Group *g) { return g->name() == name; }'' is a C++ Lambda function (an anonymous function).
	This lambda function use uses a 'capture.' The square braces at #1 name the captured variable. Its value is taken from the current environment when the lambda is instantiated at runtime and used at #3 in the function.		This lambda function use uses a 'capture.' The square braces at #1 name the captured variable. Its value is taken from the current environment when the lambda is instantiated at runtime and used at #3 in the function.
	At #2 the argument to the lambda function is declared as a ''const pointer'' so the compiler knows the function won't be modifying the object.		At #2 the argument to the lambda function is declared as a ''const pointer'' so the compiler knows the function won't be modifying the object.
	C++ STL functions like ''find_if()'' take predicates (which this lambda function is) and that can streamline code quite a bit.		C++ STL functions like ''find_if()'' take predicates (which this lambda function is) and that can streamline code quite a bit.

			The return value from find_if(...) is the iterator that references the first instance in the D4Group with a name that matches ''name''.

			Note that there a many algorithms in the STL that can perform operations like searching on all the elements of a container given the beginning and ending iterators.

Jimg at 18:01, 24 November 2021

2021-11-24T18:01:31Z

← Older revision		Revision as of 18:01, 24 November 2021
Line 25:		Line 25:
	This lambda function use uses a 'capture.' The square braces at #1 name the captured variable. Its value is taken from the current environment when the lambda is instantiated at runtime and used at #3 in the function.		This lambda function use uses a 'capture.' The square braces at #1 name the captured variable. Its value is taken from the current environment when the lambda is instantiated at runtime and used at #3 in the function.
	At #2 the argument to the lambda function is declared as a ''const pointer'' so the compiler knows the function won't be modifying the object.		At #2 the argument to the lambda function is declared as a ''const pointer'' so the compiler knows the function won't be modifying the object.
	C++ STL functions like ''find_if()'' take predicates (which ~~is what~~ this lambda function is) and that can streamline code quite a bit.		C++ STL functions like ''find_if()'' take predicates (which this lambda function is) and that can streamline code quite a bit.

Jimg at 18:00, 24 November 2021

2021-11-24T18:00:39Z

← Older revision		Revision as of 18:00, 24 November 2021
Line 22:		Line 22:
	</pre>		</pre>

	Where ''[grp_name](const D4Group *g) { return g->name() == grp_name; }'' is a C++ Lambda (anonymous function).		Where ''[grp_name](const D4Group *g) { return g->name() == grp_name; }'' is a C++ Lambda function (anonymous function).
	This use uses a 'capture.' The square braces at #1 name the captured variable. Its value is taken from the current environment when the lambda is instantiated at runtime and used at #3 in the function.		This lambda function use uses a 'capture.' The square braces at #1 name the captured variable. Its value is taken from the current environment when the lambda is instantiated at runtime and used at #3 in the function.
	At #2 the argument to the lambda function is declared as a ''const pointer'' so the compiler knows the function won't be modifying the object.		At #2 the argument to the lambda function is declared as a ''const pointer'' so the compiler knows the function won't be modifying the object.
	C++ STL functions like ''find_if()'' take predicates (which is what this lambda function is) and that can streamline code quite a bit.		C++ STL functions like ''find_if()'' take predicates (which is what this lambda function is) and that can streamline code quite a bit.

Jimg: Created page with "= Using lambdas with the STL = Change code like:

  // Note that in order for this to work the second argument must not be a reference.  // jhrg 8/20/13  static bool  na..."

2021-11-24T17:59:49Z

Created page with "= Using lambdas with the STL = Change code like: <pre> // Note that in order for this to work the second argument must not be a reference. // jhrg 8/20/13 static bool na..."

New page

= Using lambdas with the STL =

Change code like:

<pre>
// Note that in order for this to work the second argument must not be a reference.
// jhrg 8/20/13
static bool
name_eq(D4Group *g, const string name)
{
return g->name() == name;
}

groupsIter g = find_if(grp_begin(), grp_end(), bind2nd(ptr_fun(name_eq), grp_name));
</pre>

to:
<pre>
auto g = find_if(grp_begin(), grp_end(), [grp_name](const D4Group *g) { return g->name() == grp_name; });
^ ^ ^
1 2 3
</pre>

Where ''[grp_name](const D4Group *g) { return g->name() == grp_name; }'' is a C++ Lambda (anonymous function).
This use uses a 'capture.' The square braces at #1 name the captured variable. Its value is taken from the current environment when the lambda is instantiated at runtime and used at #3 in the function.
At #2 the argument to the lambda function is declared as a ''const pointer'' so the compiler knows the function won't be modifying the object.
C++ STL functions like ''find_if()'' take predicates (which is what this lambda function is) and that can streamline code quite a bit.