DIP44: scope(class) and scope(struct)

[Dmitry Olshansky]

27-Aug-2013 01:30, H. S. Teoh пишет:
> On Sun, Aug 25, 2013 at 12:18:27AM +0200, Tobias Pankrath wrote:
>> On Saturday, 24 August 2013 at 20:11:14 UTC, H. S. Teoh wrote:
>>> How would you use RAII to solve this problem? If I have a class:
>>>
>>> 	class C {
>>> 		Resource1 res1;
>>> 		Resource2 res2;
>>> 		Resource3 res3;
>>> 		this() {
>>> 			...
>>> 		}
>>> 	}
>>>
>>> How would you write the ctor with RAII such that if it successfully
>>> inits res1 and res2, but throws before it inits res3, then only res1
>>> and res2 will be cleaned up?
>>
>> Like someone else already proposed: Using a wrapper type W that
>> releases the resources in it's destructor. W.init wouldn't release
>> anything. So by definition (if I recall the rules correctly) every
>> new instance of C would have res3 = Resource3.init prior to it's
>> constructor called.
>>
>> Now make sure that a) res3's destructor gets called (check) b)
>> res3's destructor may be called on Resource3.init. That would be a
>> new rule similar to 'no internal aliasing' and c) that every
>> constructor of C either sets res3 to a destructable value or does
>> not touch it at all ('transactional programming').
> [...]
>
> But don't you still need to manually cleanup in the case of ctor
> failure? AFAIK, the dtor is not invoked on the partially-constructed
> object if the ctor throws. So you'd still have to use scope(failure) to
> manually release the resource.
>
> To prove my point, here is some sample code that (tries to) use RAII to
> cleanup:
>
> 	import std.stdio;
> 	
> 	struct Resource {
> 		int x = 0;
> 		this(int id) {
> 			x = id;
> 			writefln("Acquired resource %d", x);
> 		}
> 		~this() {
> 			if (x == 0)
> 				writefln("Empty resource, no cleanup");
> 			else
> 				writefln("Cleanup resource %d", x);
> 		}
> 	}
> 	
> 	struct S {
> 		Resource res1;
> 		Resource res2;
> 		Resource res3;
> 	
> 		this(int) {
> 			res1 = Resource(1);
> 			res2 = Resource(2);
> 			assert(res1.x == 1);
> 			assert(res2.x == 2);
> 	
> 			throw new Exception("ctor failed!");
> 			res3 = Resource(3);	// not reached
> 			assert(res3.x == 3);	// not reached
> 		}
> 	}
> 	
> 	void main() {
> 		try {
> 			auto s = S(123);
> 		} catch(Exception e) {
> 			writeln(e.msg);
> 		}
> 	}
>
> Here is the program output:
>
> 	Acquired resource 1
> 	Empty resource, no cleanup
> 	Acquired resource 2
> 	Empty resource, no cleanup
> 	ctor failed!
>
> As you can see, the two resources acquired in the partially-constructed
> object did NOT get cleaned up. So, RAII doesn't work in this case.

Fixed?

 > 			auto r1 = Resource(1);
 > 			auto r2 = Resource(2);
 > 			assert(res1.x == 1);
 > 			assert(res2.x == 2);
 > 	
 > 			throw new Exception("ctor failed!");
 > 			auto r3 = Resource(3);	// not reached
 > 			assert(res3.x == 3);	// not reached

			res1 = move(r1);
			res2 = move(r2);
			res3 = move(r3);


Exception-safe code after all has to be exception safe.
Unlike in C++ we have no explicit initialization of members (and strict 
order of this) hence no automatic partial cleanup.

-- 
Dmitry Olshansky