V> if ((const Foo *pFoo = getFoo()) == VALUE) {
V>    //работаем далее с pFoo
V> }
V> //здесь уже pFoo нет
V>

for (const Foo* pFoo = getFoo(); pFoo == VALUE; ++pFoo) 
{
  //работаем далее с pFoo
}
//здесь уже pFoo нет

struct MatchFoo
{
    Foo value;
    Foo pattern;
    MatchFoo(Foo v, Foo p) : value(v), pattern(p) {}
    operator bool() const { return value == pattern; }
};

if(MatchFoo /*const*/ mf = MatchFoo(getFoo(), VALUE))
    std::cout << mf.value << "==" << VALUE << std::endl;

template<class Value>
struct match_t
{
    Value value;
    bool matched;
    match_t(Value v, bool m) : value(v), matched(m) {}
    virtual operator bool() const { return matched; }
};

template<class Value, class Pred>
match_t<Value> match_if(Value v, Pred p) { return match_t<Value>(v, p(v)); }

template<class Value>
match_t<Value> match_with(Value v, Value p) { return match_t<Value>(v, v==p); }

int getFoo();
int const VALUE;
void test()
{
    if(match_t<int> mf = match_with(getFoo(), VALUE))
        std::cout << mf.value << "==" << VALUE << std::endl;
}

template<class Value>
struct match_t
{
    Value value;
    match_t(Value v) : value(v) {}
    virtual operator bool() const = 0;
};
// и наследники, порождаемые функциями
template<class Value, class Pred>
struct match_if_t : match_t<Value>
{
    Pred pred;
    match_t(Value v, Pred p) : match_t(v), pred(p) {}
    virtual operator bool() const { return pred(value); }
};

template<class Value, class Pred> match_if_t<Value,Pred> match_if(Value v, Pred p)
    { return match_if_t<Value,Pred>(v,p); }
template<class Value> match_if_t<Value,binder2nd<equal_to<Value> > match_with(Value v, Value p)
    { return match_if_t<Value,binder2nd<equal_to<Value> >(v, bind2nd(equal_to<Value>(),p)); }

.....
    if(match_t<int> const& mf = match_with(getFoo(), VALUE))
        .....
.....

 if (const Foo *pFoo = getFoo()) {
   //работаем далее с pFoo
 }
 //здесь уже pFoo нет

 if ((const Foo *pFoo = getFoo()) == VALUE) {
    //работаем далее с pFoo
 }
 //здесь уже pFoo нет

 const Foo *pFoo = getFoo();
 if (pFoo){
    //работает далее с pFoo
 }
 //здесь уже pFoo нет

Foo& f = getFoo();
// работаем с f

V> const Foo *pFoo = getFoo();
V> if (pFoo){
V>    //работает далее с pFoo
V> }
V> //здесь уже pFoo нет
V>

{ // Открыли блок в котором будет жить pFoo 
  const Foo *pFoo = getFoo();
  if (pFoo == VALUE)
  {
  }
  // здесь pFoo есть
} // а здесь уже рыбы нет.

if (const *pBar = dynamic_cast<const Bar*>(getFoo()))
{
}
else if (const *pFoo = dynamic_cast<const Foo*>(getFoo()))
{
}
else if (...

R>for (const Foo* pFoo = getFoo(); pFoo == VALUE; ++pFoo) 
R>{
R>  //работаем далее с pFoo
R>}
R>//здесь уже pFoo нет
R>

    for (Foo *p = foo(); p && p->zz == value;)
    {
        p->hurr_hurr();
    }

V> if ((const Foo *pFoo = getFoo()) == VALUE) {
V>    //работаем далее с pFoo
V> }
V> //здесь уже pFoo нет
V>

using(X x = getX())
if(i_like(x) && x.is_very_nice())
{
    . . .
}

{
  const Foo *pFoo = getFoo();
  if (pFoo){
    //работает далее с pFoo
  }
}
//здесь уже pFoo нет

__>>Foo& f = getFoo();
__>>// работаем с f
__>>

__>>А если getFoo проваливается выскакивает исключение

boost::optional<Foo*> getFoo()
{
 if(some_condition)
   return boost::optional<Foo*>(x);
 else
   return boost::optional<Foo*>();
}

void f(boost::optional<Foo*> foo)
{
 if(foo)
  // работаем
}

f(getFoo());

V>вот про задачи с подобным контекстом я и спрашиваю. хотел бы ограничить область видимости переменной, используемой для 5-6 строчек кода, используемой в определенной подзадаче. вот и все.

V> if (const Foo *pFoo = getFoo()) {
V>   //работаем далее с pFoo
V> }
V> //здесь уже pFoo нет
V>

V> if ((const Foo *pFoo = getFoo()) == VALUE) {
V>    //работаем далее с pFoo
V> }
V> //здесь уже pFoo нет

condition:
  expression
  typespecifier seq declarator = assignment expression

if(int i = f())
{
 //...
}
else
{
  i = 0;  
}

if (Object& o = get_object(); o.is_valid() )
{
  // работаем с o
}

if (Object1& o1 = get_object1(); Object2* o2 = get_object2(); o1.field == o2->field )
{
  // работаем с o1, o2
}

if ( declaration-list_opt; expression_list_opt ) statement;

#define DOUBLE_FOR(decl1, decl2, cond1, cond2, upd1, upd2) \
    using(decl1) \
    for(decl2; (cond1) && (cond2); (upd1), (upd2))

doSomething();

using(Lock lock(mutex))
{
    doSomethingElse();
}

doSomething();

{
    Lock lock(mutex);

    doSomethingElse();
}