class A{/*...*/}; 
class B{/*...*/};

class C
{
  A a_;
  B b_;

  void fun()const;
};

I>Да я имел в виду именно это. А как еще это можно было понять/назвать?

class A
{
   class NestedInA{};
};

I> A a(); 
I> const B b = a.get_b();            // ok
I> B bb = a.get_b();                 // compiler error!
I>

class A
{
public:
   A & operator = (int){return *this;}
};

const A fun(){return A();}

int main()
{
   fun() = 1;
}

class A
{
public:
     static int sfuncA()
     {
         return 3; // всё в порядке
         return i_; // а вот тут ошибка компилятора, т.к. статическая функция класса не имеет доступа к переменным и к this.
     }
private:
     int i_;
}

A * a = NULL;
int b = a->sfuncA(); // ошибки нет, даже с учётом того, что указатель NULL;

L_L>class A{/*...*/}; 
L_L>class B{/*...*/};

L_L>class C
L_L>{
L_L>  A a_;
L_L>  B b_;

L_L>  void fun()const;
L_L>};
L_L>

class B
{
 int f(void);
}

class A
{
 B b;
public:
 const B& get_b(void) {return b;}
};

...
{
 A a();
 a.get_b().f();        // compiler error!
}

 A a();
 const B b = a.get_b();            // ok
 B bb = a.get_b();                 // compiler error!

I>>Да я имел в виду именно это. А как еще это можно было понять/назвать?

L_L>class A
L_L>{
L_L>   class NestedInA{};
L_L>};
L_L>

class A
{
 class NestedInA{} na;
}

A a = A();

L_L>Кроме того, A a(); — это объявление функции, а не объекта. И потому до ОК дело не дойдет, не скомпилится

I>Теперь понял . Честно говоря никогда так не делал. Это реально используется? Этот класс будет доступен для инстанциации вне класса А?

class A
{
  class NestedInA{};
};

A::NestedInA a; // ошибка, так как вложенный класс недоступен

class B
{
public:
   class NestedInB{};
};

B::NestedInB b; //нормально

I>class A
I>{
I> class NestedInA{} na;
I>}
I>

I>A a = A();
I>

struct A{
   void fun(){}
};

int main()
{
   A a();
   a.fun();
}

class A
{
public:
   A(int);
};

int main()
{
   double d = 1.;
   A nonObj(int(d));// - это опять объявление функции, возвращающей А и принимающей целое
   A nonObj1(int()); // и даже это - объявление функции, ее параметр - указатель на функцию
   A obj((int)d); // вот это объект
}

class A
{
 int a;
};
class B
{
 int b;
public:
 B(void) {b = 0;}
}

{
 int a;   // значение a неопределено
 A a;     // A::a неопределено
 B b;     // B::b == 0
 A a();   // если бы так можно было, то A::a == 0
 B b();   // если бы так можно было, то эквивалентно B b;
}

I>Ну Вы меня совсем запутали На что действует и на что не действует?

 A a;                              // круглые скобки удалены :)
 const B b = a.get_b();            // ok
 B bb = a.get_b();                 // compiler error! (1)

void fun();

int main()
{
   fun(1,2,3,4);
   return 0;
}

void fun(int, int, int, int)
{
}

I>>class A
I>>{
I>> int a;
I>>};
I>>class B
I>>{
I>> int b;
I>>public:
I>> B(void) {b = 0;}
I>>}

I>>{
I>> int a;   // значение a неопределено
I>> A a;     // A::a неопределено
I>> B b;     // B::b == 0
I>> A a();   // если бы так можно было, то A::a == 0
I>> B b();   // если бы так можно было, то эквивалентно B b;
I>>}
I>>

class A
{
public:
  int a;
};

The expression T(), where T is a simple-type-specifier ....

#include <iostream>

class A
{
public:
   virtual ~A(){}
   int i_;
};

int main()
{
   std::cout<<A().i_<<std::endl;
}