[#absl-StrJoin-080]
= xref:absl.adoc[absl]::StrJoin
:relfileprefix: ../
:mrdocs:

Joins a range of elements and returns the result as a std::string.

== Synopsis

Declared in `<absl/strings/str_join.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template<
    typename Iterator,
    typename Formatter>
std::string
StrJoin(
    Iterator start,
    Iterator end,
    std::string_view sep,
    Formatter&& fmt);
----

== Description

`absl::StrJoin()` takes a range, a separator string to use between the elements joined, and an optional Formatter responsible for converting each argument in the range to a string.

If omitted, the default `AlphaNumFormatter()` is called on the elements to be joined.

Example 1: // Joins a collection of strings. This pattern also works with a collection // of `absl::string_view` or even `const char*`. std::vector<std::string> v = {"foo", "bar", "baz"}; std::string s = absl::StrJoin(v, "‐"); EXPECT_EQ(s, "foo‐bar‐baz");

Example 2: // Joins the values in the given `std::initializer_list<>` specified using // brace initialization. This pattern also works with an initializer_list // of ints or `absl::string_view` ‐‐ any `AlphaNum`‐compatible type. std::string s = absl::StrJoin({"foo", "bar", "baz"}, "‐"); EXPECT_EQs, "foo‐bar‐baz");

Example 3: // Joins a collection of ints. This pattern also works with floats, // doubles, int64s ‐‐ any `StrCat()`‐compatible type. std::vector<int> v = {1, 2, 3, ‐4}; std::string s = absl::StrJoin(v, "‐"); EXPECT_EQ(s, "1‐2‐3‐‐4");

Example 4: // Joins a collection of pointer‐to‐int. By default, pointers are // dereferenced and the pointee is formatted using the default format for // that type; such dereferencing occurs for all levels of indirection, so // this pattern works just as well for `std::vector<int**>` as for // `std::vector<int*>`. int x = 1, y = 2, z = 3; std::vector<int*> v = {&x, &y, &z}; std::string s = absl::StrJoin(v, "‐"); EXPECT_EQ(s, "1‐2‐3");

Example 5: // Dereferencing of `std::unique_ptr<>` is also supported: std::vector<std::unique_ptr<int>> v v.emplace_back(new int(1)); v.emplace_back(new int(2)); v.emplace_back(new int(3)); std::string s = absl::StrJoin(v, "‐"); EXPECT_EQ(s, "1‐2‐3");

Example 6: // Joins a `std::map`, with each key‐value pair separated by an equals // sign. This pattern would also work with, say, a // `std::vector<std::pair<>>`. std::map<std::string, int> m = { {"a", 1}, {"b", 2}, {"c", 3}}; std::string s = absl::StrJoin(m, ",", absl::PairFormatter("=")); EXPECT_EQ(s, "a=1,b=2,c=3");

Example 7: // These examples show how `absl::StrJoin()` handles a few common edge // cases: std::vector<std::string> v_empty; EXPECT_EQ(absl::StrJoin(v_empty, "‐"), "");

std::vector<std::string> v_one_item = {"foo"}; EXPECT_EQ(absl::StrJoin(v_one_item, "‐"), "foo");

std::vector<std::string> v_empty_string = {""}; EXPECT_EQ(absl::StrJoin(v_empty_string, "‐"), "");

std::vector<std::string> v_one_item_empty_string = {"a", ""}; EXPECT_EQ(absl::StrJoin(v_one_item_empty_string, "‐"), "a‐");

std::vector<std::string> v_two_empty_string = {"", ""}; EXPECT_EQ(absl::StrJoin(v_two_empty_string, "‐"), "‐");

Example 8: // Joins a `std::tuple<T...>` of heterogeneous types, converting each to // a std::string using the `absl::AlphaNum` class. std::string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "‐"); EXPECT_EQ(s, "123‐abc‐0.456");

== Return Value

The joined string.

== Parameters

[cols="1,4"]
|===
| Name| Description
| *start*
| Iterator to the first element to join.
| *end*
| Iterator past the last element to join.
| *sep*
| The separator placed between joined elements.
| *fmt*
| The formatter used to convert each element to a string.
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#