Допустим, есть вектор с целыми числами, и требуется поделить все его числа на два. Те, которые не делятся, нужно просто выкинуть. Это несложно написать циклом, но для выразительности воспользуемся алгоритмами:

std:vector<int> numbers_in;
std:vector<int> numbers_out;

// задача: поделить на 2 все чётные числа из numbers_in
// и записать результаты numbers_out
std:vector<int> intermediate;

// скопируем в intermediate только чётные числа
std::copy_if(numbers_in.begin(), numbers_in.end(),  
             std::back_inserter(intermediate), 
             [](int x) {
                        return x % 2 == 0;
             }
);

// поделим их на 2
std::transform(intermediate.begin(), intermediate.end(),
               std::back_inserter(numbers_out),
               [](int x) {
                          return x / 2;
               }
)

std::remove_if(numbers_in.begin(), numbers_in.end(), [](int& x){ const int s = x; x /= 2; return (s%2)==1; } );

numbers_in.erase(std::remove_if(numbers_in.begin(), numbers_in.end(), [](int& x){ const int s = x; x /= 2; return (s%2)==1; } ), numbers_in.end());

BFE>std::remove_if(numbers_in.begin(), numbers_in.end(), [](int& x){ const int s = x; x /= 2; return (s%2)==1; } );
BFE>

   numbers_in.erase(std::remove_if(numbers_in.begin(), numbers_in.end(), [](int& x){ const int s = x; x /= 2; return (s%2)==1; } ), numbers_in.end());

  for(int x : numbers_in) if (!(x % 2)) numbers_out.push_back(x / 2);

numbers_in.erase(std::remove_if(numbers_in.begin(), numbers_in.end(), [](int& x){ const int s = x; x /= 2; return (s%2)==1; } ), numbers_in.end());

numbers_in.filter(x => x % 2 == 0).map(x => x / 2)

for(int x : numbers_in) if (!(x % 2)) numbers_out.push_back(x / 2);

bnk>Особенно сравнивая с нормальными языками

numbers_in.filter(x => x % 2 == 0).map(x => x / 2)

numbers_in | filtered([](int x) { return !(x % 2); }) | transformed([](int x) { return x / 2; })

numbers_in.filter(x => x % 2 == 0).map(x => x / 2)

r = [3, 4, 5, 6, 7, 8].filter {|x| x % 2 == 0}.map {|x| x/2}
p r # => [2, 3, 4]

numbers_in.filter(x => x % 2 == 0).map(x => x / 2)

numbers_out = numbers_in.filter(x => x % 2 == 0).map(x => x / 2).ToArray<int>();

for(int x : numbers_in) if (!(x % 2)) numbers_out.push_back(x / 2);

Но если всё же вам необходимо вычислить всё сразу, вы можете по старинке сложить все элементы диапазона в какой-нибудь контейнер:

numbers_vector = std::vector(number_out.begin(), numbers_out.end());

Ну и в-третьих, а чем, в данном случае, хуже "лобовое" решение с использованием обычного цикла?

Допустим, есть вектор с целыми числами, и требуется поделить все его числа на два. Те, которые не делятся, нужно просто выкинуть.

Это несложно написать циклом, но для выразительности воспользуемся алгоритмами

R>  for(int x : numbers_in) if (!(x % 2)) numbers_out.push_back(x / 2);
R>

for(const int x : numbers_in) if (!(x % 2)) numbers_out.push_back(x / 2);

// задача: поделить на 2 все чётные числа из numbers_in
// и записать результаты в numbers_out
std:vector<int> intermediate;

auto v_pred = [](my_item p) { return p % 2 == 0; };
auto v_mod = [](my_item p) { return p / 2; };
std::ranges::copy(
  std::ranges::filter_view(v_src, v_pred) | std::views::transform(v_mod),
  std::back_inserter(v_dest)
);

auto v_mod_1 = [](my_item p) { return std::div(p, 2); };
auto v_pred = [](const std::div_t & p) { return p.rem == 0; };
auto v_mod_2 = [](const std::div_t & p) { return p.quot; };
std::ranges::copy(
  std::ranges::transform_view(v_src, v_mod_1) | std::views::filter(v_pred) | std::views::transform(v_mod_2),
  std::back_inserter(v_dest)
);

for( auto it : v_src ) if( std::div_t res = std::div(it, 2); res.rem == 0 ) { v_dest.push_back(res.quot); }

for( auto it : v_src ) if( it % 2 == 0 ) { v_dest.push_back(it / 2); }

for: 201us
for: 138us
algo: 198us
algo: 130us
for div: 349us
for div: 363us
algo div: 587us
algo div: 508us

std::transform(numbers_in.begin(), numbers_in.end(), numbers_in.begin(), [](int x){ return x/2;});