/// checked C# code sample
string s = "We are going to greet";
try
{
  foreach(Person p in Holidayers)
    {
        s+= " " + p.Name + ","
    }
}
catch
{
    // перед входом в обработчик все объекты возвращаются в то состояние, которое они имели перед try. 
    s+= " everyone"; 
    // поэтому теперь s = "We are going to greet everyone";
}
Console.WriteLn(s);

S>/// checked C# code sample
S>string s = "We are going to greet";
S>try
S>{
S>  foreach(Person p in Holidayers)
S>    {
S>        s+= " " + p.Name + ","
S>    }
S>}
S>catch
S>{
S>    // перед входом в обработчик все объекты возвращаются в то состояние, которое они имели перед try. 
S>    s+= " everyone"; 
S>    // поэтому теперь s = "We are going to greet everyone";
S>}
S>Console.WriteLn(s); 
S>

#include <iostream>
#include <string>
#include <stdexcept>

template< class T >
class    value_guard_t
    {
        T &    holder_;
        T    old_;
        bool    committed_;

    public :
        value_guard_t( T & holder )
            :    holder_( holder )
            ,    old_( holder )
            ,    committed_( false )
            {}
        ~value_guard_t()
            {
                if( !committed_ )
                    holder_ = old_;
            }

        void
        commit()
            {
                committed_ = true;
            }
    };

void
throwable_action( std::string & a )
    {
        a = "This is damaged content!";

        throw std::runtime_error( "Something going wrong!" );
    }

void
try_to_be_exception_safe()
    {
        std::string s( "We are going to greet" );
        try
            {
                value_guard_t< std::string > s_guard( s );

                throwable_action( s );

                s_guard.commit();
            }
        catch( const std::exception & x )
            {
                std::cerr << "Oops! Exception: " << x.what() << std::endl;
                s += " everyone";
            }

        std::cout << "And now: " << s << std::endl;
    }

int
main()
    {
        try_to_be_exception_safe();
    }

try
    {
        common_guard_t guard;
        value_guard_t< std::string > s_guard( guard, s );
        ...
        guard.commit_all();
    }

try
    {
        struct special_guard_t
            {
                ~special_giard_t()
                    {
                        if( !committed_ )
                            do_something_special();
                    }
                ...
            } special_guard;
            
        ...
        special_guard.commit();
    }

void func1() throw(my_exception) {
    throw my_exception();
}
void func2() throw() {
    func1();
}

void func1() throws MyException {
    throw new MyException();
}
void func2() {
    func1();
}

void func1() throws MyException {
    throw new MyException();
}
void func2() {
    try {
        func1();
    }
    catch(MyException exc) {
        // . . .
    }
}

void func1() throws MyException {
    throw new MyException();
}
void func2() throws MyException {
    func1();
}

E>try
E>    {
E>        common_guard_t guard;
E>        value_guard_t< std::string > s_guard( guard, s );
E>        ...
E>        guard.commit_all();
E>    }
E>

public static void Fail()
{
  string step = null;
  try
    {
      a = "step1"; 
        //blablabla
      a = "step2"; 
        throw new Exception("Shift happens");
    }
    catch(e)
    {
        Log.Trace(e, step);
        throw; 
    }
}

try
  this.a = PerformSomeAction(1, b);
    this.a++;
    this.a-= PerformSomeOtherAction()
catch(SomeExc e)
{
  this.a = PerformFallback(b);
}

try
  {
      this.a = DummyMethodForRollbacking(b);
    }
catch(SomeExc e)
{
  this.a = PerformFallback(b);
}