无条件地从构造函数中抛出* [英] Unconditionally throw *this from constructor
问题描述
我认为从构造函数的内部抛出*这是合法的。我想知道我是否简单地错了（在构造函数完成之前传递对象的问题），或者这是否是风格可恶的。
I发布了第二个更具体的问题 here 已被全面回答。这个帖子中的代码是合法的，如果有点奇怪。
给定一个异常结构：
struct fail final：public std :: logical_error
{
fail（）：std :: logic_error（fail）{}
使用std :: logic_error： ：logic_error;
};
和一堆电话网站，如：
throw fail（）;
//或
throw fail（哦亲爱的）;
我正在考虑将结构更改为：
struct fail final：public std :: logic_error
{
fail（）：std :: logic_error（fail）{throw * this; }
fail（const char * w）：std :: logic_error（w）{throw * this; }
};
在这一点上，呼叫站点可以保持不变，或者被更改为较短的：
fail（）;
//或
fail（哦亲爱的）;
这本质上意味着我不再需要写在整个地方。我也可以使用名称fail继续捕获异常。这确实似乎有效，但让我怀疑我可能会后悔这个选择。
谢谢
编辑：稍微多一点关于这个行为。
1 / Throw *这将会制作一个*这个副本或移动它，如果这是公平的游戏对于复制检测，所以逻辑错误触发的析构函数不是问题
2 /没有成员的类的默认复制构造函数可能只是复制构造函数base可以复制*这个
3 /通过异常返回的*的副本可能对于未在初始化列表中设置的任何成员有未定义的值
4 /在构建过程中可以调用成员函数。 （默认）复制构造函数是一个成员函数，因此可以在构造过程中调用它。 throw *这将调用copy构造函数。所以我仍然相信代码是合法的
我同情你写表达性代码的愿望。
$ b
这是我在代码库中使用的一种东西，特别是当调用C API作为布尔类整数返回成功或失败时。
#include< stdexcept>
#include< exception>
struct failure：std :: runtime_error
{
using runtime_error :: runtime_error;
};
template< class Message>
[[noreturn]]
bool fail（Message&& msg）
{
throw failure（std :: forward< Message>（msg））;
}
int main（）
{
extern bool didSomething（）;
didSomething（）或fail（无法做到）;
}
更有趣的例外：
#include< stdexcept>
#include< exception>
#include< cstdio>
#include< memory>
#include< system_error>
#include< sstream>
#include< iostream>
#include< iomanip>
命名空间native
{
struct no_message {};
constexpr no_message join（）{return {}; }
template< class First，class ... Rest>
std :: string join（First&& first，Rest&& ... rest）
{
std :: ostringstream ss;
ss<<第一;
使用expand = int [];
void（expand {0，
（（ss<< rest），0）...
}）;
return ss.str（）;
}
[[noreturn]]
void throwSystemError（no_message，int code）
{
throw std :: system_error（code，std :: system_category（））;
}
template< class Message>
[[noreturn]]
void throwSystemError（Message&& message，int code）
{
throw std :: system_error（code，std :: system_category（），message ）;
}
模板< class ...零件>
[[noreturn]]
bool systemError（Parts&& ... parts）
{
auto err = errno;
throwSystemError（join（std :: forward< Parts>（parts）...），err）;
}
struct file_closer {
void operator（）（FILE * fp）const noexcept {
std :: fclose（fp）;
}
};
使用FilePtr = std :: unique_ptr< FILE，file_closer> ;;
bool valid（FilePtr const& p）{return p.get（）;
FilePtr openFile（const char * path，const char * mode）
{
auto ptr = FilePtr（std :: fopen（path，mode））;
valid（ptr）或systemError（打开文件，std :: quoted（path），in mode，std :: quoted（mode））;
return ptr;
}
}
int main（）
try
{
auto fptr = native :: openFile（ibetthisdoesntexist .txt，rb）;
}
catch（std :: system_error const& syserr）
{
std :: cerr<< 系统错误：
<< syserr.what（）
<< ，错误代码<< syserr.code（）。value（）
<<的std :: ENDL;
std :: exit（100）;
}
示例输出：
系统错误：在rb模式下打开文件ibetthisdoesntexist.txt：没有这样的文件或目录，错误代码2
I believe it's legal to throw *this from within the body of a constructor. I'd like to know if I'm simply wrong about this (issues passing around an object before it's constructor has completed?) or whether this is stylistically abhorrent.
I posted a second, more specific question here which has been answered comprehensively. The code in this post is legal, if a little odd.
Given an exception struct:
struct fail final : public std::logic_error
{
fail() : std::logic_error("fail") {}
using std::logic_error::logic_error;
};
and a bunch of call sites like:
throw fail();
// or
throw fail("oh dear");
I am considering changing the struct to be:
struct fail final : public std::logic_error
{
fail() : std::logic_error("fail") { throw * this; }
fail(const char* w) : std::logic_error(w) { throw * this; }
};
At which point the call sites can remain unchanged, or be rewritten as the shorter:
fail();
// or
fail("oh dear");
This essentially means I no longer have to write throw all over the place. I can also continue catch the exception using the name "fail". It certainly seems to work, but leaves me with the suspicion that I may regret this choice later.
Thank you
edit: Thought slightly more about the behaviour.
1/ Throw *this is going to either make a copy of *this or move it if this counts as fair game for copy elision, so the destructor of logic_error firing isn't a problem
2/ The default copy constructor of a class with no members is probably just the copy constructor of the base so can probably copy *this
3/ The copy of *this that gets returned via the exception probably has undefined values for any members that are not set in the initialiser list
4/ Member functions can be called during construction. The (default) copy constructor is a member function so can be called during construction. throw *this will call the copy constructor. So I still believe the code is legal
I have sympathy with your desire to write expressive code.
This is the kind of thing I came up with for use in our code base, particularly when calling C APIs that return success or failure as an boolean-like integer.
#include <stdexcept>
#include <exception>
struct failure : std::runtime_error
{
using runtime_error::runtime_error;
};
template<class Message>
[[noreturn]]
bool fail(Message&& msg)
{
throw failure(std::forward<Message>(msg));
}
int main()
{
extern bool didSomething();
didSomething() or fail("couldn't do it");
}
More fun with exceptions:
#include <stdexcept>
#include <exception>
#include <cstdio>
#include <memory>
#include <system_error>
#include <sstream>
#include <iostream>
#include <iomanip>
namespace native
{
struct no_message {};
constexpr no_message join() { return {}; }
template<class First, class...Rest>
std::string join(First&& first, Rest&&...rest)
{
std::ostringstream ss;
ss << first;
using expand = int[];
void(expand{ 0,
((ss << ' ' << rest),0)...
});
return ss.str();
}
[[noreturn]]
void throwSystemError(no_message, int code)
{
throw std::system_error(code, std::system_category());
}
template<class Message>
[[noreturn]]
void throwSystemError(Message&& message, int code)
{
throw std::system_error(code, std::system_category(), message);
}
template<class...Parts>
[[noreturn]]
bool systemError(Parts&&...parts)
{
auto err = errno;
throwSystemError(join(std::forward<Parts>(parts)...), err);
}
struct file_closer {
void operator()(FILE* fp) const noexcept {
std::fclose(fp);
}
};
using FilePtr = std::unique_ptr<FILE, file_closer>;
bool valid(FilePtr const& p) { return p.get(); }
FilePtr openFile(const char* path, const char* mode)
{
auto ptr = FilePtr(std::fopen(path, mode));
valid(ptr) or systemError("opening file", std::quoted(path), "in mode", std::quoted(mode));
return ptr;
}
}
int main()
try
{
auto fptr = native::openFile("ibetthisdoesntexist.txt", "rb");
}
catch(std::system_error const& syserr)
{
std::cerr << "system error: "
<< syserr.what()
<< ", error code " << syserr.code().value()
<< std::endl;
std::exit(100);
}
example output:
system error: opening file "ibetthisdoesntexist.txt" in mode "rb": No such file or directory, error code 2
这篇关于无条件地从构造函数中抛出*的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
