Salve a tutti,
SIccome le eccezioni non mi piacciono, le ritengo poco eleganti (ancor di più se si usa noexcept(false)) ed in più è molto facile abusarne, mi sono ispirato a golang (scommetto che non sono il primo ad averlo fatto) ed ho sviluppato un metodo strutturato in questo modo:
#include <iostream>
#include <string>
#include <variant>
class Error {
const std::string msg;
public:
Error(const std::string &msg);
const std::string &getMsg() const;
friend std::ostream &operator<<(std::ostream &os, const Error &error);
};
template <class T, class E = Error>
class Result {
std::variant<T, E> value;
const bool error;
public:
Result(E err) : error(true), value(err) {};
Result(T data): error(false), value(data) {};
operator bool() const{
return not error;
}
T& operator*() {
if (error) abort();
return std::get<T>(value);
}
T operator*() const {
if (error) abort();
return value.data;
}
E& getError() {
if(not error) abort();
return std::get<E>(value);
}
E getError() const {
if(not error) abort();
return value.error;
}
bool isError() const {
return error;
};
};
questo andrebbe usato nel seguente modo:
Result<std::string> test(bool f) {
if(f)
return {"ciao"};
else
return Error("Error");
};
int main(int argc, char **argv) {
auto e1 = test(false);
if(e1) {
std::cout << *e1 << std::endl;
} else {
std::cerr << "[Error]:\t" << e1.getError() << std::endl;
}
}
Ora vorrei calcolare quanto questo mio metodo sia meno efficiente dell'utilizzo classico delle eccezioni:
#include <iostream>
#include <string>
#include <exception>
std::string test(bool f) noexcept(false){
if(f)
return "ciao";
else
throw std::string("no");
};
int main(int argc, char **argv) {
try {
auto e1 = test(false);
} catch (std::string &e) {
std::cout << "[Error]:\t" << e << std::endl;
};
}
Come posso capire questa cosa? Esistono tool già pronti? devo fare test esattamente come farei per un qualsiasi altro software?