Как эффективно использовать std::variant для обработки ошибок в C++?
Недавно я начал изучать использование std::variant в современном C++ (C++17 и более поздних версиях) для одновременной обработки ошибок и возврата значений из функций, что чем-то похоже на тип Result в Rust. Я понимаю основы использования std::variant, но мне нужны эффективные и элегантные шаблоны, специально предназначенные для обработки ошибок.
Вот что я пробовал до сих пор:
#include <iostream>
#include <variant>
#include <string>
using Result = std::variant<std::string, int>;
Result computeValue(int x) {
if (x < 0) {
return "Negative input error";
}
return x * 2;
}
void handleResult(const Result& result) {
std::visit([](auto&& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, std::string>) {
std::cout << "Error: " << arg << std::endl;
} else {
std::cout << "Computed value: " << arg << std::endl;
}
}, result);
}
int main() {
Result res1 = computeValue(10);
Result res2 = computeValue(-1);
handleResult(res1);
handleResult(res2);
return 0;
}
В настоящее время я ищу отзывы по следующим вопросам:
- Соображения эффективности при таком использовании
std::variant. - Любые потенциальные ловушки или улучшения, которые можно внести в этот шаблон.
- Насколько этот подход отличается от использования исключений или других традиционных методов обработки ошибок с точки зрения производительности и ясности кода?
Я был бы признателен за любые идеи или примеры лучших практик использования std::variant для обработки ошибок.
Посмотрите пример в документе . Эта версия с "перегрузкой" ИМХО гораздо читабельнее и приятнее.
В любом случае я бы так не делал, вы смешиваете результат с представлением (английский текст для внутренней ошибки). enum class ComputeError { None, NegativeInput };, а затем struct ComputeValueResult { ComputeValueError error; int value; }; А затем в дескрипторе результата вы можете использовать значение перечисления для создания строкового представления, а в других ситуациях вы можете использовать значение перечисления для ветвления в вашей бизнес-логике.
Ответы 1
Соображения эффективности при таком использовании
std::variant.
Поскольку вам придется идти по счастливому пути, на многих платформах это будет менее производительно, чем использование исключений, которые могут быть почти нулевыми накладными расходами, если их не создавать.
Любые потенциальные ловушки или улучшения, которые можно внести в этот шаблон.
std::string — довольно распространенный тип. Что произойдет, если у вас есть строковая операция, которая может завершиться неудачно?
Вероятно, вы захотите создать определенный тип Error, даже если это всего лишь
struct Error {
std::string what;
};
Также было бы неплохо «поднять» операции над int в тип Result:
template <typename UnaryOperation>
Result transform(UnaryOperation op, Result input) -> Result {
return std::visit([](auto&& arg) {
using T = decltype(arg);
if constexpr (std::is_same_v<std::decay_t<T>, Error>) {
return std::forward<T>(arg);
} else {
return op(std::forward<T>(arg));
}, input);
}
template <typename BinaryOperation>
Result transform(BinaryOperation op, Result lhs, Result rhs) -> Result {
return std::visit([](auto&& left, auto&& right) {
using L = decltype(left);
using R = decltype(right);
if constexpr (std::is_same_v<std::decay_t<L>, Error> && std::is_same_v<std::decay_t<R>, Error>) {
return Error{ std::forward<L>(left).what + std::forward<R>(right).what };
} else if constexpr (std::is_same_v<std::decay_t<L>, Error>){
return std::forward<L>(left);
} else if constexpr (std::is_same_v<std::decay_t<R>, Error>){
return std::forward<R>(right);
} else {
return op(std::forward<L>(left), std::forward<R>(right));
}, lhs, rhs);
}
Если вы умеете использовать C++23, для этой цели предназначен
std::expected.