SomeClass sc(2);
...
someFunc(sc);
if(!sc.isValid())
  sc.SomeClass::SomeClass(7); // объявления нет, только определение
otherFunc(sc);
...

template<typename T>
void setBySwap( T &dst, T toSet ) // такой тип toSet выбран специально!
{
    std::swap( dst, toSet )
}

SomeClass sc(2);
..
someFunc(sc);
if(!sc.isValid())
  setBySwap<SomeClass>( sc, 7 ); 
otherFunc(sc);
...

E>template<typename T>
E>void setBySwap( T &dst, T toSet ) // такой тип toSet выбран специально!
E>{
E>    std::swap( dst, toSet )
E>}

E>SomeClass sc(2);
E>..
E>someFunc(sc);
E>if(!sc.isValid())
E>  setBySwap<SomeClass>( sc, 7 ); 
E>otherFunc(sc);
E>...

template<class _Ty> inline
    void swap(_Ty& _Left, _Ty& _Right)
    {    // exchange values stored at _Left and _Right
    _Ty _Tmp = _Left;
    _Left = _Right, _Right = _Tmp;
    }

struct A
{
    int arg_;
    A(int arg) : arg_(arg) { std::cout << "A::A(), arg_ = " << arg_ << std::endl; }
    ~A() { std::cout << "A::~A(), arg_ = " << arg_ << std::endl; }
};

int main(int argc, char* argv[])
{
    {
        A a(4);
        a.A::A(5);
    }
    return EXIT_SUCCESS;
}

выход
=================
A::A(), arg_ = 4
A::A(), arg_ = 5
A::~A(), arg_ = 5

...
    A a(4);
    a.~A();
    a.A::A(5);
...
выход
=================
A::A(), arg_ = 4
A::~A(), arg_ = 4
A::A(), arg_ = 5
A::~A(), arg_ = 5

P>SomeClass sc(2);
P>...
P>someFunc(sc);
P>if(!sc.isValid())
P>  sc.SomeClass::SomeClass(7); // объявления нет, только определение
P>otherFunc(sc);
P>...

SomeClass sc = 123;
// требуется, чтобы был доступен конструктор копирования,
// т.к. по сути это эквивалентно записи
SomeClass sc( SomeClass(123) );
// хотя компилятор и вправе сэкономить на копировании

SomeClass sc(123); // вуаля!

if(!sc.isValid())
    new(&sc)SomeClass(7); // стандартная форма, в отличие от ms-specific

template<typename T> my_foolish_ptr {
public:
    my_foolish_ptr( T* p_ = 0 ) : p ( p_ ) {}
    ~my_foolish_ptr() { delete p; }
    
    T* get_unsafe() const { return p; }
    T* get() const { assert( p != 0 ); return p; }
    T* operator -> () const { return get(); }
    T& operator * () const { return *get(); }

    swap_with( my_foolish_ptr& other ) { std::swap( p, other.p ); }

private:
    T* p;
    
    my_foolish_ptr( const my_foolish_ptr& ); // тела нет
    void operator = ( const my_foolish_ptr& ); // тела нет
};
namespace std {
    template<typename T> void swap( my_foolish_ptr<T>& a1, my_foolish_ptr<T>& a2 ) { a1.swap_with( a2 ); }
}//namespace std

P>...
P>    A a(4);
P>    a.~A();  // Так нельзя. Никто не обещал, что так получится
P>    a.A::A(5);  // мало того, никто не обещал, что теперь второй деструктор отработает удачно...
P>...   
P>

      extern int i;   // declares but does not define i
      int i;          //  declares and defines i

P>>SomeClass sc(2);
P>>...
P>>someFunc(sc);
P>>if(!sc.isValid())
P>>  sc.SomeClass::SomeClass(7); // объявления нет, только определение
P>>otherFunc(sc);
P>>...
К>

К>SomeClass sc = 123;
К>// требуется, чтобы был доступен конструктор копирования,
К>// т.к. по сути это эквивалентно записи
К>SomeClass sc( SomeClass(123) );
К>// хотя компилятор и вправе сэкономить на копировании

К>SomeClass sc(123); // вуаля!
К>

К>if(!sc.isValid())
К>    new(&sc)SomeClass(7); // стандартная форма, в отличие от ms-specific
К>

MZ>      sc.~SomeClass();
MZ>      new(&sc)SomeClass(7);

template<class T>
class scoped_var : boost::noncopyable
{
    boost::aligned_storage<T> var;
    bool created_;
public:
    T* get() { return (T*)var.address(); }
    bool created() const { return created_; }
    
    explicit scoped_var(bool c=true) : created_(c) { if(c) create(); }
    ~scoped_var() { destroy(); }
    
    void destroy()
    {
        if(!created) return;
        created_ = false;
        get()->~T();
    }
    void create()
    {
        destroy();
        new(get()) T();
        created_ = true;
    }
    template<class A1> void create(const A1& a1)
    {
        destroy();
        new(get()) T(a1);
        created_ = true;
    }
    template<class A1, class A2> void create(const A1& a1, const A2& a2)
    {
        destroy();
        new(get()) T(a1,a2);
        created_ = true;
    }
    // etc.
};
.....
scoped_var<SomeClass> sc_impl(false);
ScopedVar& sc = *sc_impl.get();
    // ходим по краю пороховой бочки - разыменование указателя на несконструированный объект

sc_impl.create(12);
if(!sc.isValid())
    sc_impl.create(7);

E>Пример приведи, а то как-то не ясно зачем бы это так делать

void foo()
{
    // создаётся какой-то немеряный локальный контекст
    X x;
    Y y;
    Z z;
    // в котором участвует и наша переменная
    File f;
    f.open( setup1() );
    blablabla1();
    if( xz1 ) f.reopen( setup2() );
    blablabla2();
    if( xz2 ) f.reopen( setup3() );
    blablabla3();
    f.close();
}

void foo()
{
    X x; Y y; Z z;
    auto_ptr<File> f;
    
    f.reset(new File(setup1()));
    blablabla1();
    if( xz ) f.reset(new File(setup2()));
    blablabla2();
    if( xz ) f.reset(new File(setup3()));
    blablabla3();
    f.reset(0);
}

void foo()
{
    X x; Y y; Z z;
    
v1:
    {
        File f(setup1());
        blablabla1();
        if( xz1 ) goto v2;
        blablabla2();
        if( xz2 ) goto v3;
        blablabla3();
        return;
    }
v2:
    {
        File f(setup2());
        blablabla2();
        if( xz2 ) goto v3;
        blablabla3();
        return;
    }
v3:
    {
        File f(setup3());
        blablabla3();
        return;
    }
}