Re: RAII not always applicable?
On Jun 2, 11:42 pm, Frank Birbacher <bloodymir.c...@gmx.net> wrote:
Hi!
I read between the lines and I think I know what you mean. You want to
initialize objects directly to reduce state within the object. That is
you don't have to check for initialization conditions when using the
object. A small silly example:
// invariant: name.size() > 5
struct InitMe {
InitMe() : initialized(false) {} //does not fully init
void init(std::string const& newName)
{
if(initialized)
throw std::runtime_error("...");
if(newName.size()<=5)
throw std::runtime_error("...");
name = newName;
initialized = true;
}
void printName() //needs initialized==true
{
if( ! initialized) //I don't want to check this
throw std::runtime_error("...");
std::cout.write(name.c_str(), 5);
}
private:
std::string name;
};
InitMe me;
std::string newName;
stream >> newName;
me.init(newName);
me.printName();
restor schrieb:
First situation is the std::istream interface for reading the data;
that is, the operator >>. If you want to read a piece of data from the
stream interface, you first have to create an object with a useless
value and then override that value with operator >>, like in the below
example:
T val;
std::cin >> val;
To me the obvious way to do this is (or "work around"):
// invariant: name.size() > 5
struct InitMe2 {
InitMe(std::string const& newName)
: name(newName)
{
if(newName.size()<=5)
throw std::runtime_error("...");
}
void printName()
{
std::cout.write(name.c_str(), 5);
}
private:
const std::string name; //can make const
};
std::string newName;
stream >> newName;
InitMe2 me(newName);
This approach also gives opportunity to make the class members const
(like InitMe2::name) or even to make the class instance "me" const.
The general approach would either pass all needed variables to the ctor
or use a dedicated struct with all necessary data. This struct could
also define an operator >> to read itself from a stream. The struct
could also be placed inside the class:
struct InitMe3 {
struct Data {
std::string name;
};
InitMe3(Data const& newData)
: data(newData)
{
if(data.name.size()<=5)
throw std::runtime_error("...");
}
void printName()
{
std::cout.write(data.name.c_str(), 5);
}
private:
const Data data;
};
I've been thinking about this some recently. Currently my
approach requires default ctors and then using a Receive
function to reset the data members. This approach is kind
of nice as it works when you want to use return codes.
My options are to add support for a stream ctor that is
only used when you are using exceptions. That seems like
a reasonable thing to do, but I don't think it completely
eliminates the need for the default ctor or Receive function.
Here's two examples:
(vector<Account>) // The message consists of a number of Account
// instances being sent/received.
In this case, the generated Receive function would look like this
void
Receive(Buffer* buf, vector<Account>& abt1)
{
// get number of elements in vector
for (int i = 0; i < headCount; ++i) {
Account acct(buf);
abt1.push_back(acct);
}
}
But if the message is just one Account instance --
(Account)
The Receive function will look like this:
void
Receive(Buffer* buf, Account& abt1)
{
abt1.Receive(buf);
}
So it seems to me that while there may be some
merit to having a stream ctor, the need for a
function very similar to the stream ctor, Receive,
may remain. On the other hand, those using return
codes can get away with just the single Receive
function. Perhaps placement new could be used to
eliminate the need for the Receive function in
the above example.
Brian Wood
Ebenezer Enterprises
www.webEbenezer.net
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]