Why allow undefined behavior ?

While I find the Ice project interesting, I have some comments.

Having just read chapter 2 and 3 of “Distributed Programming with Ice”, I wonder why a library starting without any backward compatibility problems allow users to implement “undefined behavior” ?

In the main standard Ice main-function:

int
main(int argc, char* argv[])
{
int status = 0;
Ice::CommunicatorPtr ic;
try {
ic = Ice::initialize(argc, argv);
// …
} catch (…) {
// …
}
if (ic)
ic->destroy();
}

it is undefined behavior to forget to call “destroy”(according to page 38, footnote 2)

Why isn’t Ice::Communicator simply an object, which in it’s constructor does what Ice::initialize does and in it’s destructor does what destroy. If the constructor fails, it throws an exception

int
main(int argc, char* argv[])
{
try {
Ice::Communicator ic;
// …
} catch (…) {
// …
return 1; // or EXIT_FAILURE
}
}

It’s simpler for the user, and there is no way to implement “undefined behavior”

I know that there is the class Ice::Application, but that’s not without problems either:
* It handles exceptions, and print to stderr.
What if my application has a GUI and it should show a message box in case of errors ? In general I think that type of classes should be exception neutral
* Although there is only one virtual function to override,
* (Minor issue) It uses run-time polymorphy, while static polymorphy like “curriosly recurring template pattern” or passing in a function object would do fine.

Something like the following:


namespace Ice
{

class Communicator
{
public:
Communicator()
{ /* what ever */}
~Communicator()
{ /* what ever */}
};

template <typename T>
class Application
{
public:
int main(int argc, char* argv[])
{
try {
Communicator ic;
// ...
return static_cast<T*>(this)->run(argc, argv);
}
catch(...) {
}
}
};

} // namespace Ice

class MyApplication : public Ice::Application<MyApplication>
{
public:
int run(int , char* [])
{
//...
return 0;
}
};


int main(int argc, char* argv[])
{
return MyApplication().main(argc, argv);
}




or



namespace Ice
{

class Communicator
{
public:
Communicator()
{ /* what ever */}
~Communicator()
{ /* what ever */}
};

template <int (*run_T)(int , char* [])>
class Application
{
public:
int main(int argc, char* argv[])
{
try {
Communicator ic;
// ...
return run_T(argc, argv);
}
catch(...) {
}
}
};

} // namespace Ice

int my_run(int, char* [])
{
// ...
return 0;
}

int main(int argc, char* argv[])
{
return Ice::Application<my_run>().main(argc, argv);
}




Kind regards

Mogens Hansen