Как отделить вывод типа от объявления параметров функции?

Содержание

Вопрос или проблема
Ответ или решение
Отделение дедукции типов от объявления параметров функции в C++
Введение
Проблема
Решение
Объяснение решения
Заключение

Вопрос или проблема

Я заметил значительное ускорение в своем приложении, если моя функция foo принимает примитивные типы по значению вместо универсальной (перемещающей) ссылки. Однако ускорение теряется, если непримитивные типы не передаются по универсальной ссылке. Если бы foo принимала фиксированное число аргументов, это бы сработало:

#include <cstdio>
#include <string>
#include <type_traits>

template <typename T>
requires (!std::is_scalar_v<T>)
auto foo(T&&){
    std::puts("передача по универсальной ссылке");
}

template <typename T>
requires std::is_scalar_v<T>
auto foo(T){
    std::puts("передача по значению");
}

int main(){
    foo(42);  // передача по значению
    foo(std::string{"hello"}); // передача по универсальной ссылке
    
    return 0;
}

Однако проблема в том, что foo принимает пакет параметров шаблона, и некоторые параметры могут быть примитивами, а другие – нет. Таким образом, foo сначала должна вывести типы параметров, а затем, если они не примитивы, преобразовать их в универсальные ссылки. Если бы foo была шаблоном класса, это можно было бы реализовать с помощью направляющих вывода:

#include <cstdio>
#include <string>
#include <type_traits>

template <typename T>
using MaybeRef = std::conditional_t<std::is_scalar_v<T>, T, T&&>;

#include <tuple>
template <typename... Ts>
struct Foo {
    
    Foo(MaybeRef<Ts>... args) {
        static_assert(std::is_same_v<std::tuple_element_t<0, std::tuple<MaybeRef<Ts>...>>, int>);
        static_assert(std::is_same_v<std::tuple_element_t<1, std::tuple<MaybeRef<Ts>...>>, std::string&>);
        std::puts("переданы");
    }
};

template <typename... Ts>
Foo(Ts&&...) -> Foo<MaybeRef<Ts>...>;

int main(){
    std::string str = "hello";
    Foo{42, str};

    return 0;
}

Тем не менее, я не знаю, как достичь того же для своей функции foo. Это вообще возможно и как?

Ответ или решение

Отделение дедукции типов от объявления параметров функции в C++

Введение

Вопрос о том, как отделить дедукцию типов от объявления параметров функции в C++, становится особенно актуальным, когда необходимо оптимизировать производительность приложения, принимая во внимание, что разные типы аргументов требуют разных подходов к передаче – по значению или по универсальной ссылке. Данная статья разберет данный вопрос с учетом предоставленных примеров кода и предложит возможные решения.

Проблема

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

В приведенном примере с шаблоном класса Foo решение достигается с помощью дедукционных направляющих, но то же самое необходимо применить для функции foo, что может показаться сложным из-за возможности передачи переменного числа параметров.

Решение

Для реализации подобной логики в функции с параметрическим пакетом, мы можем использовать механизм, аналогичный направляющим, но через конструкции, такие как std::conditional и std::index_sequence. Рассмотрим пример:

#include <cstdio>
#include <string>
#include <type_traits>
#include <utility>

// Условная обертка для определения типа аргумента
template <typename T>
using MaybeRef = std::conditional_t<std::is_scalar_v<T>, T, T&&>;

template <typename... Ts>
void foo(MaybeRef<Ts>... args) {
    (process(args), ...); // Обработка каждого аргумента
}

template <typename T>
void process(T& arg) {
    std::puts("pass by universal reference");
}

template <typename T>
void process(T arg) {
    std::puts("pass by value");
}

int main() {
    foo(42);  // pass by value
    std::string str = "hello";
    foo(str); // pass by universal reference

    return 0;
}

Объяснение решения

Using MaybeRef: Мы определили тип MaybeRef, который использует std::conditional_t для проверки, является ли тип примитивным или нет. Если это так, то тип остается без изменений, в противном случае он становится универсальной ссылкой.
Обработка Аргументов: Используя fold expression для получения списков аргументов, мы можем вызвать функцию process, которая обрабатывает как примитивные, так и не примитивные типы в зависимости от их характеристик.
Оптимизация: Передавая примитивные типы по значению, мы выигрываем в производительности, тогда как не примитивные типы передаются по ссылке, что предотвращает копирование больших структур данных.

Заключение

Таким образом, мы реализовали разделение дедукции типов от объявления параметров функции в C++, что позволяет оптимизировать производительность приложения, учитывая разные типы аргументов. Использование std::conditional и fold expressions дает нам гибкий и эффективный инструментарий для работы с универсальными ссылками. Решение, предложенное в данной статье, должно помочь вам в дальнейшей разработке и оптимизации ваших C++ приложений.