Thread: Idea for new language construct

Many times when writing functions/methods I've wanted some kind of function-destructor concept. A piece of code that always runs when returning no matter where you're returning from. Of course similar effects can be done using smart pointers, additional function calls etc... but it'd be nice to have an easy-to-use buildt-in construct for this.

The basic structural idea:

Code:

int Func()
{
  first
  {
    int* x = new int(1337)

    if(Something()) return 0
    if(SomethingElse()) return 0
    if(YetSomethingElse()) return 0

    return *x
  }
  then
  {
    delete x
  }
}

The function-destructor is called after the return value has been pushed to the stack so the dereference (*x) will be safe. You won't be able to use return-statements in the destructor as it would screw things up.

Comments? Do you think this would make a useful addition?

>Comments? Do you think this would make a useful addition?
Something like a finally block for functions? I honestly don't see the need for it when you can achieve the same effect with RAII and a little planning.

I'm not sure Magos.

Some compilers already implement that through function attributes, if I recall correctly, and that is probably how I would like best to have it implemented as a standard if it ever came to see the light of day.

Code:

void foo(){   /*... */   }  //function definition

void foo() __attribute__((destructor()) { /*... */ } //function destructor definition

I think that would better match how destructors and constructors are used in classes. A first-then statement is perhaps too surprising since the flow of the code is afffected in ways you haven't seen before in C++.

I agree with Prelude. The try...finally construct in Java and C#, which does what you want, is a crutch developed to make up for the lack of deterministic object destruction.

As I mentioned smart pointers *could* be used instead, but to give a sligtly different example:

Code:

bool PerformTasks()
{
  first
  {
    if(!Task1()) return false;
    if(!Task2()) return false;
    if(!Task3()) return false;
    if(!Task4()) return false;
    if(!Task5()) return false;
    if(!Task6()) return false;

    return true;
  }
  then
  {
    Cleanup();
  }
}

Without duplicating the call to Cleanup, without having hugely nested if-statements and without having a huge if-test I see no clean and efficient way of performing this task.

Code:

bool PerformTasks()
{
  struct sentinel { ~sentinel() { Cleanup(); } } s;

  if(!Task1()) return false;
  if(!Task2()) return false;
  if(!Task3()) return false;
  if(!Task4()) return false;
  if(!Task5()) return false;
  if(!Task6()) return false;

  return true;
}

And the code isn't even more indented (something I don't like about try...catch).

Doesn't C++ free memory under non-static variables in functions???

The idea here was to suggest a construct that *might* or *might not* be useful in certain situations, simplify syntax and/or as an alternative. As an example in C++ you can do:

Code:

int a, b, c;

Though entirely pointless as you can just do:

Code:

int a;
int b;
int c;

It's still there for basically the same reasons as above. And for the record I'm not trying to claim my construct is the one truth. I asked for opinions, and I got them. Thanks.

For each new there must be a delete. Always.

Originally Posted by Mario F.

For each new there must be a delete. Always.

I never use new