Блог

В следующем примере мне нужен traverse метод, который получает обратный вызов. Этот пример отлично работает, как только я ничего не фиксирую [] , потому что лямбда-выражение можно свести к указателю на функцию. Однако в данном конкретном случае я хотел бы получить доступ sum .

 struct Collection {
    int array[10];

    void traverse(void (*cb)(int amp;n)) {
        for(int amp;i : array)
            cb(i);
    }

    int sum() {
        int sum = 0;
        traverse([amp;](int amp;i) {
            sum  = i;
        });
    }
}
  

Каков правильный способ (без использования каких-либо шаблонов) решить эту проблему? Решение заключается в использовании typename шаблона следующим образом. Но в этом случае вам не хватает видимости того, что дает траверс на каждой итерации (an int ):

 template <typename F>
void traverse(F cb) {
    for(int amp;i : array)
        cb(i);
}
  

Типы лямбда не указаны; нет способа их назвать.

Итак, у вас есть два варианта:

• Создайте traverse шаблон (или возьмите его auto , что фактически одно и то же)

  К счастью, это совершенно нормальная и обычная вещь.

• traverse Возьмите a std::function<void(int)> . Это влечет за собой некоторые накладные расходы, но, по крайней мере, означает, что функция не обязательно должна быть шаблоном.

Но в этом случае вам не хватает видимости того, что дает traverse на каждой итерации (int)

Мы не склонны считать это проблемой. Я понимаю, что указание этого в типе функции более удовлетворительно и понятно, но, как правило, комментария достаточно, потому что, если обратный вызов не предоставляет an int , вы все равно получите ошибку компиляции.

С указателями на функции можно использовать только лямбда-выражения без захвата. Поскольку каждое определение лямбда-выражения имеет свой собственный тип, вы должны использовать параметр шаблона во всех местах, где вы принимаете лямбда-выражения, которые захватывают.

Но в этом случае вам не хватает видимости того, что дает traverse на каждой итерации (int ).

Это можно легко проверить с помощью SFINAE или еще проще с помощью концепций в C 20. И чтобы упростить его еще на один шаг, вам даже не нужно определять концепцию и использовать ее позже, вы можете напрямую использовать специальное требование как это (это приводит к двойному использованию requires ключевого слова:

 struct Collection {
    int array[10];


    template <typename F>
        // check if F is "something" which can be called with an `intamp;` and returns void.
        requires requires ( F f, intamp; i) { {f(i)} -> std::same_as<void>; }
        void traverse(F cb) 
        {   
            for(int amp;i : array)
                cb(i);
        }

     // alternatively you can use `std::invocable` from <concepts>

    // check if F is "something" which can be called with an `intamp;`, no return type check 
    template <std::invocable<intamp;> F>
        void traverse2(F cb) 
        {   
            for(int amp;i : array)
                cb(i);
        }   

    int sum() {
        int sum = 0;
        traverse([amp;](int amp;i) {
            sum  = i;
        });

        return sum;
    }
};

  

В вашем случае у вас есть несколько способов объявить обратный вызов на C :

Указатель на функцию

 void traverse(void (*cb)(int amp;n)) {
    for(int amp;i : array)
        cb(i);
}
  

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

Шаблон имени типа

 template <typename F>
void traverse(F cb) {
    for(int amp;i : array)
        cb(i);
}
  

Он принимает что угодно, но, как вы заметили. код трудно читать.

Стандартные функции (C 11)

 void traverse(std::function<const void(int amp;num)>cb) {
    for(int amp;i : array)
        cb(i);
}
  

Это наиболее универсальное решение с небольшими накладными расходами.

Не забудьте включить <functional> .