Range-based for loop with auto specifier combined with static_cast - c++

Question

Imaged that I have an std::vector of std::string, and I want to convert those std::string to std::string_view in range-based for loop:
auto v = std::vector<std::string>{"abc", "def", "ghi"};
for (std::string_view sv : v) {
// do something with string_view
}
The above code is perfectly valid, but I want to remain the auto specifier to do that, how to do static_cast in one line range-based for loop like this? It seems like C++20 ranges can do this in a concise way, can someone give an example?
for (auto sv : v | static_cast<std::string_view>) {
// do something with std::string_view
}

Answer 1

Not that this is a good idea as written, but this might be a useful example of a more general transform concept (and an evil lambda trick):
for(auto sv : v |
views::transform([](std::string_view x) {return x;})) …

Answer 2

You could, as #Elijay comments, simply create a new vector of string_views:
for (auto sv : vector<string_view>(v.begin(), v.end()))
but this kind of defeats the whole purpose of using string_view in the first place: to avoid copying.
It also, as commented below, kind of defeats the whole purpose of auto: to avoid unnecessarily restating type information. Here the type is being introduced for the first time so must be explicitly stated. Why not right up front in plain view?
Less verbose and using string_view as intended is where you started:
for (string_view sv : v)

Answer 3

You can do something like this:
#include <string>
#include <vector>
#include <iostream>
#include <string_view>
int main() {
auto v = std::vector<std::string>{"abc", "def", "ghi"};
for (auto sv : std::vector<std::string_view>(v.begin(), v.end())) {
// use sv ...
}
}
However note that creating a whole new vector is not at all recommended. It allocates memory again and causes a lot of unnecessary overhead. Besides, you have to spell the type somewhere anyway, so auto doesn't have any advantages at all here. The Right ThingTM to do is specifying the type name explicitly and not using auto.

Answer 4

Iterators is a good customization point, unfortunately it requires quite some boilerplate:
#include <vector>
#include <iostream>
#include <string_view>
template <typename T>
struct container_view {
const T& container;
container_view(const T& t) : container(t) {}
struct iterator{
typename T::const_iterator base;
iterator(const typename T::const_iterator& it) : base(it) {}
bool operator!=(const iterator& other) { return base != other.base; }
iterator& operator++() { ++base; return *this; }
std::string_view operator*() { return {*base}; }
// ^--- string_view
};
iterator begin() { return {container.begin()};}
iterator end() { return {container.end()};}
};
int main (){
auto v = std::vector<std::string>{"abc", "def", "ghi"};
// v--- auto
for (auto sv : container_view(v)) {
std::cout << sv << '\n';
}
}

Answer 5

Arguably more/less succinct. Opinions will vary.
#include <vector>
#include <string_view>
#include <string>
#include <iostream>
#include <range/v3/view/transform.hpp>
int main()
{
auto v = std::vector<std::string>{"abc", "def", "ghi"};
using namespace ranges;
auto as_string_view = views::transform([](auto&& x) { return std::string_view(x); });
for (auto sv : v | as_string_view) {
std::cout << sv << '\n';
}
}