How to get maximum element in a vector that belongs to a range?

Not always it pays off to squeeze too much in a single line, or to use algorithms always, especially when the loop is clear and readable. Anyhow, if you like you can use std::accumulate. The binary operation is rather close to your original code, I just used the conditional operator instead of an if:

auto x = std::accumulate(arr.begin(),arr.end(),-1,[high,low](int accu,int elem){
    return (elem > accu && elem >= low && elem <= high ) ? elem : accu;
});

Live Demo

Similar to @Yksisarvinen's answer, but using std::tuple's < to shorten it.

This has a precondition that there is at least one element within range in the input.

#include <cassert>
#include <algorithm>
#include <tuple>
#include <vector>

int main() {
    std::vector<int> arr {3,5,7,9,5,1,6,7,4,2};
    int lowerLimit = 4;
    int upperLimit = 8;
    
    auto inRange = [lowerLimit, upperLimit](int value)
    {
        return value >= lowerLimit && value <= upperLimit;
    };
    auto compare = [inRange](int lhs, int rhs) {
        return std::tuple(inRange(lhs), lhs) < std::tuple(inRange(rhs), rhs);
    };
    
    assert(!arr.empty());
    assert(std::any_of(arr.begin(), arr.end(), inRange));
    auto it = std::max_element(arr.begin(), arr.end(), compare);
    int max = *it;
}

While others have shown feasible solutions using standard algorithms, I would like to suggest one similar to std::max_element implementation. Here, you will get more flexibility what to do, when you provide a non-valid range to the algorithm function.

#include <iterator> std::iterator_traits

template<typename Iterator>
using EleType = typename std::iterator_traits<Iterator>::value_type;

template< class Iterator>
auto my_max_element(Iterator first, const Iterator last,
    EleType<Iterator> minValue, EleType<Iterator> maxValue)
{
    Iterator largest = first;
    for (; first != last; ++first)
        if (minValue <= *first && *first <= maxValue && *largest < *first)
            largest = first;
    // final range check for the largest element
    return (minValue <= *largest && *largest <= maxValue) ? largest : last;
}

(See a Live Demo)

This is far from being a one liner (unless you consider helper functions to not be part of the code, then it sure is one line), but if you really want to use standard algorithms, you need a comparison function that will conform to strict weak ordering.

bool inRange(int value, int lowerLimit, int upperLimit)
{
    return value >= lowerLimit && value <= upperLimit;
}

std::vector<int> arr {3,5,7,9,5,1,6,7,4,2};
    
int lowerLimit = 4;
int upperLimit = 8;
auto compare = [lowerLimit, upperLimit](int l, int r){
    if(inRange(l, lowerLimit, upperLimit) && inRange(r, lowerLimit, upperLimit)) {
        // both values are in range, so compare them
        return l < r;
    } else if (inRange(r, lowerLimit, upperLimit)) {
        // r is in range, l is not, l should compare smaller
        return true;
    } else if (inRange(l, lowerLimit, upperLimit)) {
        // l is in range, r is not, r should compare smaller
        return false;
    } else {
        // both are out of range, compare them normally to keep strict weak ordering requirements
        return l < r;
    }
};

auto maxIter = std::max_element(std::begin(arr), std::end(arr), compare);
std::cout << "Max value is " << *maxIter;

Here's one that utilizes the two standard lib functions std::sort and std::find_first_of:

#include <iostream>
#include <vector>
#include <tuple>
#include <algorithm>

// Find max element of sample vector within range of val_range.
using namespace std;

int main()
{
    vector<int> sample = { 3,5,7,9,5,1,6,7,4,2 };
    vector<int> val_range = { 4,8 };

    // Sort in reverse order
    sort(sample.begin(), sample.end(), greater<int>());
    vector<int>::iterator it = find_first_of(sample.begin(), sample.end(), val_range.begin(), val_range.end(), [](int value, int max_val) {return value <= max_val;} );
    cout << (*it) << endl;
}

See Live Demo

#include <algorithm> // for lower_bound, upper_bound and sort
#include <iostream>
#include <vector> 
using namespace std;

int main() {

    vector<int> v = {3,5,7,9,5,1,6,7,4,2};
    
    
    sort(v.begin(), v.end());
    
    auto lower =  lower_bound(v.begin(), v.end(), 8); // position of the element <= 8
    int k = lower - v.begin();
    k = (v[k] == 8) ? k : k - 1; // if-else
    (v[k] >= 4) ? cout << v[k] << endl : cout << "no Such element in given range [4,8]" << endl;    
    

}

using the STL library,

• any element which is max in the range[4,8] also max in range [1,8], therefore, the desired element is the lower bound of 8 itself.