在C++17中，没有这样的函数的直接等价物，但是对于具有快速相等比较的较小类型，可以使用std::clamp：

if (val == std::clamp(val, low, high)) {
    ...
}

或者，您可以编写自己的函数来测试此问题：

template <typename T>
    bool IsInBounds(const T& value, const T& low, const T& high) {
    return !(value < low) && (value < high);
}

这个函数检查value是否在[low，high]范围内。如果你想要[low，high]范围，你可以写为

template <typename T>
    bool IsInBounds(const T& value, const T& low, const T& high) {
    return !(value < low) && !(high < value);
}

请注意，这是如何纯粹地根据operator <定义的，这意味着这里可以使用任何只支持operator <的类。
类似地，下面是一个使用自定义比较器的例子：

template <typename T, typename R, typename Comparator>
    bool IsInBounds(const T& value, const R& low, const R& high, Comparator comp) {
    return !comp(value, low) && comp(value, high);
}

后者有一个很好的优势，low和high不必与value类型相同，只要比较器能够处理，它就可以正常工作。
希望这有帮助！

bool inBounds(int value, int low, int high)

有一个小小的缺点，那就是你必须记住哪个参数的位置。
我不可能是唯一一个在一段时间后返回代码时完全理性的参数排序令人困惑的人。
你可以多走一步

template<typename T>
class Interval
{
public:
    Interval(T lo, T hi) : low(lo), high(hi) {}
    bool contains(T value) const { return low <= value && value < high; }
private:
    T low;
    T high;
};
template<typename T>
Interval<T> interval(T lo, T hi) { return Interval<T>(lo, hi); }

然后你可以更明确地表达你的意思：

if (interval(a, b).contains(value))
    // ...

如果一个人处于抽象模式，那么归纳以适应不同的包含/排除组合并不太困难。
当然，这可能是矫枉过正为您的目的。
YMMV，还有其他的。

您可以从std::less、std::more、std::bind和std::compose中组合一个，但这确实是大材小用。
Lambda的要容易得多：
[](int value, int low, int high){return !(value < low) && (value < high);}
或者，如果范围内有低和高
[low, high](int value){return !(value < low) && (value < high)};

我几乎认为您最好不要尝试使用整个函数执行这样一个看似微不足道的任务，而只是内联行为。
大概是这样的

int main()
{
    int value = 5;
    int lower = 0;
    int upper = 10;

    bool inside = lower < value && value < upper;

    std::cout << "inside: " << inside;
}

如果您有理由不像这样简单地编写代码，请告诉我，我可以提供一个更复杂的答案。