C++ - Joining properties of a vector<custom_class> into a string - c++

Question

I have a std::vector<custom_class> which I would like to join into a comma separated string.
I found the code:
std::stringstream s;
std::string delimeter = ",";
copy(v.begin(), v.end(), std::ostream_iterator<int>(s, delimeter.c_str()));
which is great to join a vector of a single type, such as int. However, I would like to join only a certain property of my custom_class.
Can I use copy to copy and join only a certain property of my custom_class?
For example, my vector<custom_class> looks like:
v[0].A = 1
v[0].B = 2
v[0].C = 3
v[1].A = 1
v[1].B = 2
v[1].C = 3
v[2].A = 1
v[2].B = 2
v[2].C = 3
v[3].A = 1
v[3].B = 2
v[3].C = 3
And I'd like to use the std::copy to only join those values of property B (as an example) to return the value:
2,2,2,2
Is something like this possible without looping through v explicity?

Answer 1

You can use standard algorithm std::transform instead of algorithm std::copy
For example
std::transform( v.begin(), v.end(), std::ostream_iterator<int>( s, "," ),
[]( const custom_class &c ) { return c.B; } );
The other way is to use algorithm std::accumulate declared in header <numeric> and function std::to_string
For example
std::string s = std::accumulate( v.begin(), v.end(), std::string(),
[]( std::string &s, const custom_class &c )
{
return ( s += std::to_string( c.B ) + ',' );
} );

Answer 2

Joining a string is a little odd, since you need to treat empty containers specially. So it might be easiest to roll your own algorithm. Here's one that takes an extractor predicate argument:
#include <iterator>
#include <sstream>
#include <string>
#include <utility>
template <typename C, typename E>
std::string join(char const * delim, C const & c, E && e)
{
using std::begin;
using std::end;
auto it = begin(c), eit = end(c);
if (it == eit) { return {}; }
std::ostringstream os;
os << e(*it);
while (++it != eit) { os << delim << e(*it); }
return os.str();
}
Usage example:
#include <functional>
#include <iostream>
#include <vector>
int main()
{
std::vector<std::pair<int, int>> v { { 1, 4 }, { 2, 8 }, { 3, 19 }};
std::cout << join(" | ", v, std::mem_fn(&std::pair<int, int>::second)) << "\n";
}
If you just want to print out the elements themselves without applying an extractor, you can pass some kind of "identity" extractor, for example a suitable instance of std::forward. We can in fact bake this in as default arguments:
template <typename C,
typename E = typename C::value_type const &(&)(typename C::value_type const &)>
std::string join(char const * delim,
C const & c,
E && e = static_cast<typename C::value_type const &(&)(typename C::value_type const &)>(std::forward))
Now we can say e.g.:
std::vector<int> w { 1, 4, 2, 8, 3, 19 };
std::cout << join(", ", w) << "\n";