Быстрый способ STL найти вход, который дает максимальный результат функции? (непрерывные целочисленные входы)

Вы можете использовать std::max_element, определенный в <algorithm>.

Это вернет итератор к максимальному элементу в указанном диапазоне. Вы можете получить индекс, используя std::distance.

Пример скопирован с сайта cppreference.

 std::vector<int> v{ 3, 1, -14, 1, 5, 9 }; 
 std::vector<int>::iterator result;
 
 result = std::max_element(v.begin(), v.end());
 std::cout << "max element at: " << std::distance(v.begin(), result) << '\n';

В общем, алгоритмы STL работают с последовательностями значений, которые проходятся итераторами. Они также склонны возвращать итераторы. Это шаблон, который он использует.

Если вы делаете много подобных вещей, где ваша входная «последовательность» представляет собой последовательный список чисел, вам понадобится итератор, который «перебирает» последовательность (без какого-либо хранилища за ней) .

Небольшой поиск обнаружил Boost.CountingIterator, который, похоже, может делать то, что вы хотите. Я уверен, что есть и другие подобные.

Предупреждение - полностью непроверенный код

    auto iter = std::max_element(boost::counting_iterator<int>(5),
                                 boost::counting_iterator<int>(8),
          // a comparator that compares two elements
                                );
    return *iter; // should be '6'

Как заметили другие, std::max_element определяется, чтобы получить самый большой элемент в диапазоне.

В вашем случае «итератор» является целым числом, а результатом разыменования этого итератора является... некоторый результат, который не связан с вводом в явном виде (но, по-видимому, у вас есть способ получить его эффективно).

В этом случае я бы, вероятно, определил специализированный класс итератора, а затем использовал его с std::max_element:

#include <iostream>
#include <iterator>
#include <algorithm>

// your association function goes here. I've just done something
// where the relationship from input to output isn't necessarily
// immediately obvious
int association_function(int input) {
    int a = input * 65537 + 17;
    int b = a * a * a;
    return b % 127;
}

class yourIterator {
    int value;
public:
    // create an iterator from an int value
    explicit yourIterator(int value) : value(value) {}

    // "Deference" the iterator (get the associated value)
    int operator*() const { return association_function(value);  }

    // advance to the next value:
    yourIterator operator++(int) {
        yourIterator temp(value);
        ++value;
        return temp;
     }

     yourIterator &operator++() {
        ++value;
        return *this;
    }

    // compare to another iterator
    bool operator==(yourIterator const& other) const { return value == other.value; }
    bool operator!=(yourIterator const& other) const { return value != other.value; }

    // get the index of the current iterator:
    explicit operator int() const { return value; }
};

int main() {
    // For demo, print out all the values in a particular range:
    std::cout << "values in range: ";
    std::copy(yourIterator(5), yourIterator(10), std::ostream_iterator<int>(std::cout, "\t"));

    // Find the iterator that gives the largest value:
    yourIterator max = std::max_element(yourIterator(5), yourIterator(10));

    // print out the value and the index that gave it:
    std::cout << "\nLargest element: " << *max << "\n";
    std::cout << "index of largest element: " << static_cast<int>(max);
}

Когда я запускаю это, я получаю вывод следующим образом:

values in range: 64     90      105     60      33
Largest element: 105
index of largest element: 7

Итак, вроде работает корректно.

Если вам нужно использовать это с различными функциями ассоциации, вы, вероятно, захотите передать это как параметр шаблона, чтобы часть итерации не была связана с функцией ассоциации.

// pass association as a template parameter
template <class Map>
class mappingIterator {
    int value;
    // create an instance of that type:
    Map map;
public:
    // use the instance to map from iterator to value:
    int operator*() const { return map(value);  }

Затем вам нужно будет преобразовать вашу функцию ассоциации в форму, подходящую для использования в качестве параметра шаблона, например:

struct association_function {
    int operator()(int input) const {
        int a = input * 65537 + 17;
        int b = a * a * a;
        return b % 127;
    }
};

Затем в main вы, вероятно, захотите определить тип итератора в сочетании с функцией ассоциации:

    using It = mappingIterator<association_function>;
    It max = std::max_element(It(5), It(10));

Диапазоны С++ 20 могут сделать это:

template<typename T, typename F>
T argmax_iota(T begin, T end, F &&score) { // can't really think of a good name for this; maybe it doesn't even deserve its own function
    return std::ranges::max(std::views::iota(begin, end), std::less{}, std::ref(score));
    // over the values in the range [begin, end) produced by counting (iota)...
    // find the one that produces the greatest value (max)...
    // when passed to the projection function score...
    // with those values under the ordering induced by std::less
}

Годболт

iota нигде не хранит весь диапазон. Итераторы в диапазоне содержат одно значение T, которое увеличивается при увеличении итератора.