Найти «максимальный» элемент в контейнере по имени поля

#include <vector>
#include <iostream>
#include <numeric>

struct Data {
	size_t number;
	char letter;
};

int main()
{
	std::vector<Data> numbers = { Data{1, 'a'},Data{2, 'b'}, Data{3, 'c'} };
	const auto res = std::accumulate(numbers.cbegin(), numbers.cend(), numbers[0], [](Data max, Data current) {
		if (max.number > current.number) {
			return max;
		}
		return current;
	}).letter;
	std::cout << res << std::endl;
}

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

struct Data {
    size_t number;
    char letter;
};

int main() {
  std::vector<Data> numbers{
      {1, 'a'}, {2, 'b'}, {4, 'd'}, {3, 'c'},
  };

  std::cout << std::max_element(numbers.begin(), numbers.end(),
                                [](Data const &a, Data const &b) {
                                  return a.number < b.number;
                                })
                   ->letter
            << "\n";
}

max_by_key(|v| v.number)

// vs

max_by(|a, b| a.number.cmp(b.number))

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

struct Data {
    int number;
    char letter;
};

int main(int argc, char *argv[])
{
    std::vector<Data> a = { Data { 1, 'a' }, Data { 2, 'b' }, Data { 3, 'c' }};
    // Подразумевается что контейнер не пуст.
    char letter = std::max_element(std::begin(a), std::end(a), [](Data &l, Data &r) { return l.number < r.number; })->letter;
    std::cout << letter << std::endl;
    return 0;
}

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

struct Datum {
    int n;
    char c;
};

template <class F, class G> F max_field(F first, F last, G getter)
{
    return std::max_element(first, last, [&getter](auto &a, auto &b) { return getter(a) < getter(b); });
}

int main(void)
{
    std::vector <Datum> data = { Datum{1, 'a'}
                               , Datum{2, 'b'}
                               , Datum{3, 'c'}
                               };
    char letter = max_field(std::begin(data), std::end(data), [](Datum &d) { return d.n; })->c;
    std::cout << letter << std::endl;
}

#include <iostream>
#include <string>
#include <vector>

template<class InputIt, class UnaryOperation>
InputIt max_by_key(InputIt first, InputIt last, UnaryOperation op)
{
    InputIt result = first;
    
    for (; first != last; ++first) {
        result = op(std::move(*first)) > op(std::move(*result))? first : result;
    }
    
    return result;
}

struct Data {
    size_t number;
    char letter;
};

int main()
{
  std::vector<Data> numbers{
      {1, 'a'}, {2, 'b'}, {4, 'd'}, {3, 'c'},
  };

  std::cout << max_by_key(std::begin(numbers), std::end(numbers), [](const Data &a)  {return a.number; })->letter
            << "\n";
}

template<class KeyExtractor1,class KeyExtractor2>
struct key_from_key
{
public:
  typedef typename KeyExtractor1::result_type result_type;

  key_from_key(
    const KeyExtractor1& key1_=KeyExtractor1(),
    const KeyExtractor2& key2_=KeyExtractor2()):
    key1(key1_),key2(key2_)
  {}

  template<typename Arg>
  result_type operator()(Arg& arg)const
  {
    return key1(key2(arg));
  }

private:
  KeyExtractor1 key1;
  KeyExtractor2 key2;
};

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

struct Data {
  size_t number;
  char letter;
};

template <class ForwardIterator, class DataType, typename KeyType>
ForwardIterator max_by_key(ForwardIterator first, ForwardIterator last,
                           KeyType (*get_key)(DataType &)) {
  auto cmp = [get_key](DataType const &a, DataType const &b) {
    return get_key(a) < get_key(b);
  };
  return std::max_element(first, last, cmp);
}

int main() {
  std::vector<Data> numbers{
      {1, 'a'}, {2, 'b'}, {4, 'd'}, {3, 'c'},
  };

#if 1
  // Работает.
  size_t (*getter)(Data const &a) = [](Data const &a) { return a.number; };
  std::cout << max_by_key(numbers.begin(), numbers.end(), getter)->letter
            << "\n";
#else
  // Не работает.
  std::cout << max_by_key(numbers.begin(), numbers.end(),
                          [](Data const &a) { return a.number; })
                   ->letter
            << "\n";
#endif
}

struct data {
    int i;
    char c;
};

template <typename Field, typename ItrType>
ItrType max_el(ItrType begin, ItrType end, Field fld)
{
    return std::max_element(begin, end, [fld](auto lh, auto rh) {
        return lh.*fld < rh.*fld;
    });
}

int main()
{
    std::vector<data> d = {
        {3, 'a'},
        {2, 'b'},
        {1, 'c'},
    };
    auto mmm = max_el(d.cbegin(), d.cend(), &data::i);
    auto nnn = max_el(d.cbegin(), d.cend(), &data::c);

    std::cout << mmm->i << " " << mmm->c << "\n";
    std::cout << nnn->i << " " << nnn->c << "\n";

    return 0;
}

3 a
1 c

[fld](auto lh, auto rh)

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

template<typename Getter>
auto compare_by(Getter && getter) {
  return [getter](auto && a, auto && b) { return getter(a) < getter(b); };
}

struct Data {
    size_t number;
    char letter;
};

int main()
{
  std::vector<Data> numbers{
      {1, 'a'}, {2, 'b'}, {4, 'd'}, {3, 'c'},
  };

  std::cout << max_element(begin(numbers), end(numbers), compare_by([](auto && a)  {return a.number; }))->letter
            << "\n";
}

#include <vector>
#include <iostream>
#include <numeric>
#include <algorithm>

struct Data {
	size_t number;
	char letter;
	bool operator<(const Data& a) const { return this->number < a.number;}
};

int main()
{
	std::vector<Data> numbers = { Data{1, 'a'},Data{3, 'b'}, Data{2, 'c'} };
	const auto res = std::max_element(numbers.cbegin(), numbers.cend())->letter;
	std::cout << res << std::endl;
}