#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> getVec() { return {}; }

int main()
{
	auto vec = getVec();

	for_each(begin(vec), end(vec), [](decltype(vec)::value_type &v){});
}

mir ist decltype(vec) zu lang, gibts da keine schöne Abkürzung?

mir ist decltype(vec) zu lang, gibts da keine schöne Abkürzung?

Nein.

decltype(vec[0])

(ungetestet! ginge ja, falls nicht mit Indexop., auch mit at )
:xmas2:
Aber das decltype(vec) kannst du damit eben nicht verkürzen.

#include <list>
#include <vector>
#include <algorithm>
using namespace std;

list<int> getList() { return {}; }
vector<int> getVec() { return {}; }

int main()
{
	auto vec = getVec();
	auto lis = getList();

	auto func = [](auto &v) { };

	for_each(begin(vec), end(vec), func(decltype(vec)::value_type));
	for_each(begin(vec), end(vec), func(decltype(lis)::value_type));
}

auto func = []<T>(T &v) { };

for_each(begin(vec), end(vec), func<decltype(vec)::value_type>);
for_each(begin(vec), end(vec), func<decltype(lis)::value_type>);

Edit: oder eben kürzer:

// klappt auch wenn keine element drin ist, da statischer Typ angeschaut wird
for_each(begin(vec), end(vec), func<decltype(vec[0])>);
for_each(begin(vec), end(vec), func<decltype(lis[0])>);

std::transform(first, last, result, [](x){return x*2;});

ist.

decltype ist übrigens etwas kritisch, bei Identifiern, weil da noch Referenzen und dabei sein könnten. Besser wäre hier

iterator_traits<decltype(begin(vec))>::value_type

auto func = []<T>(T &v) { }; 

for_each(begin(vec), end(vec), func<int>); 
for_each(begin(vec), end(vec), func<char>);

wird nach einer source-to-source transformation zu:

auto func_int = [](int &v) { }; 
auto func_char = [](char &v) { };

for_each(begin(vec), end(vec), func_int); 
for_each(begin(vec), end(vec), func_char);

Sollte doch gehen, oder? Müsste nur aufpassen, dass der Bezeichner func_int/char nicht schon im Programm exisitiert. Ist ja aber erstmal egal, oder ich waehle halt kryptische Namen.

Sollte doch gehen, oder?

Das Lambda wird ja zu einem Archetype. Ich würde bevorzugen, dass

auto func = [](auto& v) { };

for_each(begin(vec), end(vec), func);
for_each(begin(vec), end(vec), func);

zu

struct __lambda_func // reservierter Bezeichner, muss frei sein
{
    template <class T> void operator()(T x) { }
};

auto func = __lambda_func{};

for_each(begin(vec), end(vec), func);
for_each(begin(vec), end(vec), func);

wird. Das ist schöner und wahrscheinlich näher an den polymorphic Lambdas in C++42 dran.