Оболочка для возвращаемого значения функции и std::optional

@NanoCase · Регистрация: 28.02.2023

Студворк — интернет-сервис помощи студентам

Добрый день!
Есть вот такой код:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
template <typename Func, typename Res = typename boost::function_types::result_type<Func>::type>
struct TaskWrapped
    {
        const std::function<Func> taskUnwrapped_;
        
        explicit TaskWrapped(std::function<Func> &taskUnwrapped) 
            : taskUnwrapped_(taskUnwrapped)
        {}
        explicit TaskWrapped(std::function<Func> &&taskUnwrapped) 
            : taskUnwrapped_(std::move(taskUnwrapped))
        {}
 
        template <typename... Args>
        std::optional<Res> operator()(Args &&...args) const noexcept
        //ошибка если Res = void
        {
            try
            {
                boost::this_thread::interruption_point();
            }
            catch (const boost::thread_interrupted &)
            {
                std::cerr << "thread interruption" << std::endl;
            }
            try
            {
                return taskUnwrapped_(std::forward<Args>(args)...);
            }
            catch (const std::exception &ex)
            {
                std::cerr << ex.what() << std::endl;
            }
            catch (const boost::thread_interrupted &)
            {
                std::cerr << "thread interruption" << std::endl;
            }
            catch (...)
            {
                std::cerr << "unknown error when calling the function: "
                          << boost::typeindex::type_id<Func>() << std::endl;
            }
            return std::nullopt;
        }
    };

Нужно сделать оболочку для возвращаемого значения функции, даже если оно void. Также нужно уведомить пользователя о том, что было исключение, для этого используется std::option.
Пока что так:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
namespace detail
    {
        template <typename Ty, typename = std::enable_if_t<std::is_same_v<Ty, void>>>
        struct non_void_return_value
        {
            using type = std::void_t<Ty>;//?????
        };
 
        template <typename Ty>
        struct non_void_return_value<Ty>
        {
            using type = Ty;
        };
 
        template <typename Ty>
        using non_void_return_value_t = typename non_void_return_value<Ty>::type;
 
        template <typename Ty>
        struct ProxyResult
        {
            using type = non_void_return_value_t<Ty>;
            std::optional<type> value_;
 
            ProxyResult(type&& value) : value_(value) {}
            ProxyResult(std::nullopt_t opt) : value_(opt) {}
            ProxyResult(void) {}
        };
    
        void foo(){}
        
        ProxyResult<void> foo2()
        {
            return foo();//error
        }
    }

@zayats80888 · 03.03.2023, 17:49

Сообщение от NanoCase

Нужно сделать оболочку для возвращаемого значения функции, даже если оно void.

Что-то в этом духе

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
template<class Res>
struct my_result {
    using type = std::optional<Res>;
};
 
struct dummy {};
 
template<>
struct my_result<void> {
    using type = std::optional<dummy>;
};
 
//...
 
template <typename... Args>
typename my_result<Res>::type operator()(Args &&...args) const noexcept
{
    //...
    try
    {
        if constexpr (std::is_void_v<Res>) {
            taskUnwrapped_(std::forward<Args>(args)...);
            return dummy{};
        } else {
            return taskUnwrapped_(std::forward<Args>(args)...);
        }
    }
    //...
    return std::nullopt;
}

@NanoCase · 03.03.2023, 22:02 **[ТС]**

Хорошее решение. Но в языке следующий код является валидным:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
void foo()
{
    std::cout << "foo" << std::endl;
}
void foo2()
{
    return foo();
}
int main()
{
    foo2();
}

Думаю что можно как-то сыграть от этого при помощи SFINAE и приведений типов.

@zayats80888 · 03.03.2023, 22:37

Сообщение от NanoCase

Думаю что можно как-то сыграть от этого при помощи SFINAE и приведений типов.

Выражением prvalue типа void нельзя инициализировать объект. Так что либо if constexpr, либо то же самое, только через специализацию какого-нибудь "инвокера".

@NanoCase · 03.03.2023, 22:52 **[ТС]**

Понял. Спасибо за ответ!

@DrOffset · 08.03.2023, 21:51

Сообщение от NanoCase

Думаю что можно как-то сыграть от этого

Можно сыграть.
Вот без специализаций и условий.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
namespace detail {
 
struct Dummy {};
 
template <typename Res>
std::optional<Res> operator,(Res&& res, std::optional<Dummy>) {
    return std::forward<Res>(res);
}
 
} // detail
 
template <typename... Args>
auto operator()(Args&& ...args)
{
    using detail::Dummy;
    using Ret = decltype(taskUnwrapped_(std::forward<Args>(args)...), std::optional<Dummy>());
    
    try {
        return taskUnwrapped_(std::forward<Args>(args)...), std::optional<Dummy>();
    }
    //....
    return Ret();
}

@NanoCase · 09.03.2023, 23:54 **[ТС]**

DrOffset, т.е. перегружая оператор запятая у нас появляется возможность вывести возвращаемое значение функции в виде шаблона и если на 7 строчке провал подстановки то мы инициализируем Ret пустышкой?

@zayats80888 · 10.03.2023, 00:52

Сообщение от NanoCase

и если на 7 строчке провал подстановки то мы инициализируем Ret пустышкой?

Ага, только не на 7, а на 6 (точнее, на этапе формирования списка кандидатов в перегрузи).
И на 19 строчке в конструктор optional нужно передать объект Dummy, иначе результат неотличим от того, что в строке 22.

@DrOffset · 10.03.2023, 06:53

Сообщение от zayats80888

Dummy, иначе результат неотличим от того, что в строке 22.

Да, согласен, спасибо, этот момент потерялся.

@NanoCase · 11.03.2023, 22:14 **[ТС]**

zayats80888 DrOffset, продолжаю улучшать оболочку, хочу чтобы функцию можно было вызывать из объекта, т.е. сохраняем в классе указатель на вызывающую сторону, когда хотим вызвать проверяем указатель на nullptr и вызываем соответствующий вариант функции. Но такой подход походу не работает, компилятор выдает ошибку. Можете направить меня в нужную сторону, пожалуйста

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
struct dummy
    {
    };
 
    template <typename Res>
    std::optional<Res> operator,(Res &&res, std::optional<dummy>)
    {
        return std::forward<Res>(res);
    }
 
template <class Func, class Obj = detail::dummy*>
    struct task_wrapped
    {
        const std::function<Func> taskUnwrapped_;
        const Obj* caller_;
        
        explicit task_wrapped(std::function<Func> &taskUnwrapped, Obj* caller = nullptr) 
           : taskUnwrapped_(taskUnwrapped), caller_(caller)
        {
        }
        explicit task_wrapped(std::function<Func> &&taskUnwrapped) 
           : taskUnwrapped_(std::move(taskUnwrapped))
        {
        }
 
        template <typename... Args>
        auto operator()(Args &&...args) const noexcept
        {
            using detail::dummy;
            if constexpr(caller_)
                using Ret = decltype(caller_->taskUnwrapped_(std::forward<Args>(args)...), 
                                                                                            std::optional<dummy>());
            else 
                using Ret = decltype(taskUnwrapped_(std::forward<Args>(args)...), 
                                                                                     std::optional<dummy>());
            
            //.....
            try
            {
                if constexpr(caller_ != nullptr) 
                        return caller_->taskUnwrapped_(std::forward<Args>(args)...), 
                                                             std::optional<detail::dummy>(detail::dummy{});
                else return taskUnwrapped_(std::forward<Args>(args)...), 
                                                                          std::optional<dummy>(dummy{});
            }
           //.....
            return Ret();
        }
    };

@DrOffset · 11.03.2023, 22:16

NanoCase, у вас же есть std::function, нет нужды вводить разграничение на уровне вызова, когда можно его спрятать на уровне создания функтора.

@NanoCase · 11.03.2023, 22:32 **[ТС]**

DrOffset, в std::function можно указывать вызывающую сторону?

@DrOffset · 11.03.2023, 22:38

Сообщение от NanoCase

в std::function можно указывать вызывающую сторону?

В std::bind или в лямбде можно.

Вот вариант:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <iostream>
#include <optional>
#include <string>
#include <functional>
 
namespace detail {
    struct dummy
    {
    };
 
    template <typename Res>
    std::optional<Res> operator,(Res &&res, std::optional<dummy>)
    {
        return std::forward<Res>(res);
    }
    
    template <typename F>
    struct remove_function_top_const;
    template <typename R, typename ...Args>
    struct remove_function_top_const<R(Args...)> {
        using type = R(Args...);
    };
    template <typename R, typename ...Args>
    struct remove_function_top_const<R(Args...) const> {
        using type = R(Args...);
    };
}
    template <class Func>
    struct task_wrapped
    {
        const std::function<typename detail::remove_function_top_const<Func>::type> taskUnwrapped_;
 
        template <typename Obj>
        explicit task_wrapped(Func (Obj::*fptr), Obj* caller) 
            : taskUnwrapped_(std::bind(fptr, caller))
        { }
        explicit task_wrapped(std::function<Func> &&taskUnwrapped) 
            : taskUnwrapped_(std::move(taskUnwrapped))
        {
        }
 
        template <typename... Args>
        auto operator()(Args &&...args) const noexcept
        {
            using detail::dummy;
            using Ret = decltype(taskUnwrapped_(std::forward<Args>(args)...), std::optional<dummy>());
            
            //.....
            try
            {
                return taskUnwrapped_(std::forward<Args>(args)...), std::optional<dummy>(dummy{});
            }
            catch(...)
            {
            }
            return Ret();
        }
    };
 
int main()
{
    std::string a = "test";
    
    task_wrapped<char const*() const> x(&std::string::c_str, &a);
    
    std::cout << x().value();
}

https://wandbox.org/permlink/CJc6NIesab4t2Abr

@NanoCase · 12.03.2023, 00:44 **[ТС]**

DrOffset, Вроде разобрался. Спасибо!

Добавлено через 1 час 25 минут
DrOffset, проблемка вылезла, std::bind нужны placeholders на все аргументы вызываемой функции, вроде как решается заменой bind на аналогичную лямбду, с захватом функции и caller. Вот решение близкое к правде, но он ругается на сам вызов функции в лямбде

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
#include <optional>
#include <string>
#include <functional>
 
namespace detail {
    struct dummy
    {
    };
 
    template <typename Res>
    std::optional<Res> operator,(Res &&res, std::optional<dummy>)
    {
        return std::forward<Res>(res);
    }
    
    template <typename F>
    struct remove_function_top_const;
    template <typename R, typename ...Args>
    struct remove_function_top_const<R(Args...)> {
        using type = R(Args...);
    };
    template <typename R, typename ...Args>
    struct remove_function_top_const<R(Args...) const> {
        using type = R(Args...);
    };
}
    template <class Func>    
    struct task_wrapped;
 
    template <class R, class ...Args>
    struct task_wrapped<R(Args...)>
    {
        using Func = R(Args...);
        const std::function<typename detail::remove_function_top_const<Func>::type> taskUnwrapped_;
 
        template <typename Obj>
        explicit task_wrapped(Func (Obj::*fptr), Obj* caller) 
            : taskUnwrapped_([fptr, caller](Args &&...args){return caller->fptr(args...);})//error
        { }
        explicit task_wrapped(Func &taskUnwrapped) 
            : taskUnwrapped_(taskUnwrapped)
        {
        }
        
        auto operator()(Args &&...args) const noexcept
        {
            using detail::dummy;
            using Ret = decltype(taskUnwrapped_(std::forward<Args>(args)...), std::optional<dummy>());
            
            //.....
            try
            {
                return taskUnwrapped_(std::forward<Args>(args)...), std::optional<dummy>(dummy{});
            }
            catch(...)
            {
            }
            return Ret();
        }
    };
 
    typedef task_wrapped<int(int&, int&)> callback;
    struct str
    {   
        int sum(int& a, int& b)
        {
            return a + b;
        }
    };
 
    int sum(int& a, int& b)
{
    return a+b;
}
 
int main()
{
#ifdef i
    std::string a = "test";
    task_wrapped<char const*() const> x(&std::string::c_str, &a);
    std::cout << x().value();
#else
    str st;
    int a = 3, b = 6;
    task_wrapped<int(int&, int&)> task(&str::sum, &st);
    task(a, b);
    std::cout << a;
#endif
}

@DrOffset · 12.03.2023, 00:55

NanoCase, синтаксис вызова через указатель на метод другой. Плюс забыли forward

C++
1
taskUnwrapped_([fptr, caller](Args &&...args){return (caller->*fptr)(std::forward<Args>(args)...);})

@NanoCase · 12.03.2023, 02:46 **[ТС]**

DrOffset, Заработало, спасибо

Добавлено через 1 час 8 минут
DrOffset, у меня ещё вопрос созрел(возможно глупый). Допустим я хочу передать в качестве параметра функции shared_ptr, который должен скопироваться в оператор() и следовательно в пользовательскую функцию. Можно ли это решить без перегрузок оператора() и тотального переписывания кода?

@DrOffset · 12.03.2023, 12:40

Сообщение от NanoCase

у меня ещё вопрос созрел(возможно глупый). Допустим я хочу передать в качестве параметра функции shared_ptr, который должен скопироваться в оператор() и следовательно в пользовательскую функцию. Можно ли это решить без перегрузок оператора() и тотального переписывания кода?

А в чем проблема?

C++
1
2
3
4
5
6
7
8
9
10
11
void test(std::shared_ptr<int> p) {
    // ...
}
 
int main()
{
    std::shared_ptr<int> p( new int() );
    task_wrapped<void(std::shared_ptr<int>)> x(&test);
    
    x(p);
}

@NanoCase · 12.03.2023, 13:49 **[ТС]**

DrOffset, gcc 12.2 ошибку выдает на ваш код:

C++
1
2
error: no match for call to '(task_wrapped<void(std::shared_ptr<int>)>) (std::shared_ptr<int>&)'
error: cannot bind rvalue reference of type 'std::shared_ptr<int>&&' to lvalue of type 'std::shared_ptr<int>'

@DrOffset · 12.03.2023, 14:03

NanoCase, так не на мой, а на ваш. Вы же сами класс изменили. У вас оператор теперь не соответствует новому подходу. Надо так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
        auto operator()(Args ...args) const noexcept
        {
            using detail::dummy;
            using Ret = decltype(taskUnwrapped_(args...), std::optional<dummy>());
            
            //.....
            try
            {
                return taskUnwrapped_(args...), std::optional<dummy>(dummy{});
            }
            catch(...)
            {
            }
            return Ret();
        }

@NanoCase · 12.03.2023, 14:14 **[ТС]**

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

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef task_wrapped<void()> task;
void test(std::shared_ptr<int> p) {
    // ...
}
 
int main()
{
    std::shared_ptr<int> p( new int() );
    auto layer = [p]{test(p);};
    task x(layer);
    
    x();
    
    
}

Новые блоги и статьи Все статьи Все блоги /
Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Programma_Boinc 28.12.2025 Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Налог на собак: https:/ / ********/ gallery/ V06K53e Финансовый отчет в Excel: https:/ / ********/ gallery/ bKBkQFf Пост отсюда. . .	Кто-нибудь знает, где можно бесплатно получить настольный компьютер или ноутбук? США. Programma_Boinc 26.12.2025 Нашел на реддите интересную статью под названием Anyone know where to get a free Desktop or Laptop? Ниже её машинный перевод. После долгих разбирательств я наконец-то вернула себе. . .	Thinkpad X220 Tablet — это лучший бюджетный ноутбук для учёбы, точка. Programma_Boinc 23.12.2025 Рецензия / Мнение/ Перевод Нашел на реддите интересную статью под названием The Thinkpad X220 Tablet is the best budget school laptop period . Ниже её машинный перевод. Thinkpad X220 Tablet —. . .	PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Как объединить две одинаковые БД Access с разными данными VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.
Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .	Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .

Оболочка для возвращаемого значения функции и std::optional

Решение

Решение

@NanoCase 0 / 0 / 0 Регистрация: 28.02.2023 Сообщений: 26
	03.03.2023, 22:52 [ТС]
	Понял. Спасибо за ответ! 0

@NanoCase 0 / 0 / 0 Регистрация: 28.02.2023 Сообщений: 26
	09.03.2023, 23:54 [ТС]
	DrOffset, т.е. перегружая оператор запятая у нас появляется возможность вывести возвращаемое значение функции в виде шаблона и если на 7 строчке провал подстановки то мы инициализируем Ret пустышкой? 0

@DrOffset 19491 / 10097 / 2460 Регистрация: 30.01.2014 Сообщений: 17,805
	11.03.2023, 22:16
	NanoCase, у вас же есть std::function, нет нужды вводить разграничение на уровне вызова, когда можно его спрятать на уровне создания функтора. 1

@NanoCase 0 / 0 / 0 Регистрация: 28.02.2023 Сообщений: 26
	11.03.2023, 22:32 [ТС]
	DrOffset, в std::function можно указывать вызывающую сторону? 0

@NanoCase 0 / 0 / 0 Регистрация: 28.02.2023 Сообщений: 26
	12.03.2023, 02:46 [ТС]
	DrOffset, Заработало, спасибо Добавлено через 1 час 8 минут DrOffset, у меня ещё вопрос созрел(возможно глупый). Допустим я хочу передать в качестве параметра функции shared_ptr, который должен скопироваться в оператор() и следовательно в пользовательскую функцию. Можно ли это решить без перегрузок оператора() и тотального переписывания кода? 0