Dlaczego program wypisuje tak dużo destruktorów

#include <iostream>
#include <random>
#include <vector>

thread_local std::mt19937 gen{std::random_device{}()};

template<typename T>
T random(T min, T max)
{
    return std::uniform_int_distribution<T>{min, max}(gen);
}


class IsDivisibleBy{
public:
        IsDivisibleBy(int a) : parametr(a){std::cout << "Constr ";};
        //IsDivisibleBy(const IsDivisibleBy & ref){parametr=ref.parametr; std::cout << "copy";}
        ~IsDivisibleBy(){std::cout << "Destr ";}
    bool operator()(int b){return !(b % parametr);}
private:
int parametr;
};

template <typename T, typename P>
int Count(T & v, P predicate){
    int total{0};
    for (auto & x : v) if (predicate(x)) total++;
    return total;
}


int main() {
    std::vector<int> MyVec;
    for (int i=0; i<4000; i++) MyVec.push_back(random(1,1000));
    for (int divisor=1; divisor<20; divisor++){
        std::cout << Count(MyVec, IsDivisibleBy(divisor)) << '\n';
    }

    return 0;
}

Program wypisuje dwa razy więcej destruktorów

Constr Destr 4000
Destr Constr Destr 2016
Destr Constr Destr 1314
Destr Constr Destr 993
Destr Constr Destr 859
Destr Constr Destr 660
Destr Constr Destr 564
Destr Constr Destr 491
Destr Constr Destr 443
Destr Constr Destr 419
Destr Constr Destr 379
Destr Constr Destr 317
Destr Constr Destr 281
Destr Constr Destr 288
Destr Constr Destr 281
Destr Constr Destr 252
Destr Constr Destr 258
Destr Constr Destr 216
Destr Constr Destr 215
Destr

Bo wrzucasz Predicate do count jako wartość. Zatem przy wywołaniu Count w pętli, tworzysz obiekt tymczasowy IsDivisibleBy (wywołanie konstruktora), kopiujesz go do funkcji (powinno być wywołanie konstruktora kopiującego albo przenoszącego), wywołuje się destruktor podczas usunięcia obiektu tymczasowego (pierwszy Destr), wypisujesz liczbę, wychodzisz z funkcji Count i niszczysz skopiowany do niej obiekt (drugi Destr).
Zmień, żeby Count przyjmowało referencję na przykład, to będzie jeden Destr i brak kopiowania.

Zwróć uwagę, że są konstuktory, które są domyślnie zdefiniowane:

• copy construtyor
• move constructor

Jako, że działasz na kopiach to są są one w użyciu. Domyślna implemntacja niczego niczego nie loguje, stąd w logach jest nierównowaga między liczbą konstruktorów i destruktorów
https://godbolt.org/z/abG1Wx343

Dodam tylko, że w tym wypadku zapewne chcesz mieć

template <typename T, typename P>
int Count(T & v, P&& predicate){

Kolega chyba pisze w C++14 albo niżej (i ma wyłączone optymalizacje), bo w 17tce nawet na -O i niezależnie od flag optymalizacyjnych tych dodatkowych wywołań nie ma, co w sumie zgadza się ze standardem, że kompilator ma zagwarantować copy elision gdzie to wskazane (gcc).

https://en.cppreference.com/w/cpp/language/copy_elision

Co nie zmienia w sumie faktu, że P&& w funkcji szablonowej pozwoli na forwardowanie jak się tylko żywnie spodoba (czy to przekazanie const Pred&, czy też rvalue od std::function) a kompilator lepiej to rozwiąże niż zawsze wymuszając kopię gdy tych refów nie ma.

https://godbolt.org/z/xTnrW73Wx

W programie, który podałeś, duża ilość destruktorów jest wypisywana z powodu tworzenia wielu tymczasowych obiektów klasy IsDivisibleBy. W funkcji main, dla każdej wartości divisor od 1 do 19, tworzony jest nowy obiekt klasy IsDivisibleBy przekazywany do funkcji Count. Po zakończeniu każdego wywołania funkcji Count, te tymczasowe obiekty są niszczone, co powoduje wywołanie ich destruktorów.

Aby zredukować liczbę wywołań destruktorów, możemy utworzyć wektor obiektów IsDivisibleBy przed pętlą divisor i przechować te obiekty na całkowity czas trwania programu. Oto zmodyfikowany kod:

#include <iostream>
#include <random>
#include <vector>

thread_local std::mt19937 gen{std::random_device{}()};

template<typename T>
T random(T min, T max)
{
    return std::uniform_int_distribution<T>{min, max}(gen);
}

class IsDivisibleBy{
public:
    IsDivisibleBy(int a) : parametr(a){std::cout << "Constr ";};
    ~IsDivisibleBy(){std::cout << "Destr ";}
    bool operator()(int b){return !(b % parametr);}
private:
    int parametr;
};

template <typename T, typename P>
int Count(T & v, P predicate){
    int total{0};
    for (auto & x : v) if (predicate(x)) total++;
    return total;
}

int main() {
    std::vector<int> MyVec;
    for (int i=0; i<4000; i++) MyVec.push_back(random(1,1000));

    // Utwórz wektor obiektów IsDivisibleBy
    std::vector<IsDivisibleBy> predicates;
    for (int divisor = 1; divisor < 20; ++divisor) {
        predicates.emplace_back(divisor);
    }

    // Użyj obiektów z wektora predicates zamiast tworzenia nowych
    for (auto& predicate : predicates) {
        std::cout << Count(MyVec, predicate) << '\n';
    }

    return 0;
}

Teraz, zamiast tworzyć i niszczyć obiekty IsDivisibleBy dla każdego wywołania funkcji Count, program utworzy je tylko raz i zniszczy po zakończeniu pętli. W rezultacie liczba wywołań destruktorów zostanie znacznie zmniejszona.