Re: RAII not always applicable?
restor wrote:
[snip]
If we take a plain (and perfect) example of RAII usage. Il looks like
this:
{
RAIIResource resource;
resource.use(); /// very simple usage
} // auto-release
Now, it may be insufficient if we need to know the address of the
object before it is initialized (e.g. to pass it by reference), as in
your example:
See below...
you could use a smart pointer, or a custom wrapper:
std::shared_ptr<T> val;
std::cin >> val;
First, I would use boost::optional rather than std::shared_ptr, unless
shared ownership was really required. The former doesn't allocate
anything on the heap and is therefore faster.
But the problem that still remains is that whereas T can now be a full
RAII objct, the usage is still a two-phase init with all its burden:
My proposal fixed the problem of having a non-RAII class to maintain.
It helps keep things simple and clean.
You are right, nothing has changed outside. But this was intentional.
The initial problem was given in the terms of the usage. I proposed
a solution that will give a better design, yet provide the same
use case.
Now, the way RAII class can be used may be altered by providing
a wrapper instead of 'shared_ptr' or 'optional'. You can provide
_any_ interface you would like. It may throw on "full init",
you may have a function "is_initialized()", anything goes...
About having a reference before initialization, you might be
able to use a reference to the wrapper. Something like this:
SomeResource abstract class with virtual function use().
RAII_SomeResource - implements SomeResource, a clean RAII class.
SomeResource_wrapper - implements SomeResource, handles
two-phase init, delegates to RAII_SomeResource,
can use placement-new for allocation.
I know, now it's three classes instead of one. Maybe this is why
people usually write one complex class. I think, at least concerning
the principle of separation of responsibilities and encapsulation,
it _is_ a good solution. However, I'm not sure it's usable as
a generic solution. If someone finds it usable, please let me know.
The example I provided is from the being-developed Boost library:
Boost.Coroutine. You can obtain it from Boost Vault:
http://www.boostpro.com/vault/index.php?PHPSESSID=ebfe7ae73e7578929b21aaa732
182fe1&direction=0&order=&directory=Concurrent%20Programming
I'll take a look at it...
--
Dragan
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]