В конструкторе вложенного класса инициализируется приватное поле. Потом вызывается функция-метод этого класса и выводит значение этого поля НО НЕ ТО!

#include <windows.h>
#include <iostream>
using namespace std;
 
 
//Вот главный класс
class A{
 private:
 
 //А вот вложенный
 class B { 
  public: 
 
   //А вот инициализация приватного члена i вложенного класса
   B(): i(0){} 
   void operator()(int x){ 
 
    //Ну всё, собсно. Конструктор B создан, i инициализирована должны увидеть 0
    //вместо этого видим чушь
    printf ("i= %d\n", i);
    getchar ();
   } 
  private: 
   int i ; 
 }; 
 
 public:
  A (){};
 
  //А это отдельный разговор, компилится только если возвращает объект типа B
  B B_() {
   B();
  }
};
   
 
int main() {
 A ob_1;
 ob_1.B_()(6);
 system ("pause");
}

ob_1.B_()

#include <iostream>
 
class A
{
    class B
    { 
    public:
        B(int b):
        m_b(b)
        {
        } 
    
        void operator()()
        {
            std::cout << "m_b = " << m_b << std::endl;
        }
    
    private: 
        int m_b; 
    };
 
public:
    A(int a):
    m_a(a)
    {
    }
 
    B get_a() const
    {
        return m_a;
    }
 
private:
    B m_a;
};
   
 
int main()
{
    A a(10);
 
    a.get_a()();
 
    return 0;
}

B B_() {
 
   B();
  }

B B_() {
 
   return B();
  }

ob_1.B_()

B &b = ob_1.B_();
b.operator(6);

B B_() {
 
   B();
  }

  B B_() {
   return B();
  }

B B_() 
{
 B();
} /*деструктор вызовется тут, поэтому смысла особого нет в этой функции, она вернёт непонятно чё. И приминение оператора() к этому "непонятно чему" ведёт к непредсказуемым последствиям, в лучшем случае выведет кривой i, в худшем SIGSEV. Поэтому return необходим*/

 A ob_1;
 ob_1.B_(89)();
 ob_1.B_(12)();
 ob_1.B_(34)();
 ob_1.B_(42)();
 //И так далее, не конструктор принимает int, а метод!

#include <windows.h>
#include <iostream>
using namespace std;
 
 
//Вот главный класс
class A{
 private:
 
 //А вот вложенный
 class B { 
  public: 
 
   //А вот инициализация приватного члена i вложенного класса
   B(int z): i(z){} 
   void operator()(){ 
 
    //Была чушь, теперь чё надо!!
    printf ("i= %d\n", i);
    getchar ();
   } 
  private: 
   int i ; 
 }; 
 
 public:
  A (){};
  B B_(int z) {
   return B(z);
  }
};
   
 
int main() {
 A ob_1;
 ob_1.B_(89)();
 system ("pause");
}

#include <windows.h>
#include <iostream>
using namespace std;
 
class A{
 public:
  int operator () (int x) {
   return x;
  }         
};
   
 
int main() {
 //Вот здесь
 printf ("A()(6)= %d\n", A()(6));
 system ("pause");
}

ob.f_rek(100);

ob.f_rek(100);

ob.f_rek(100)();

#include <iostream>
 
void rec_func_five_times(int x)
{
    static int i = 0;
 
    if (i == 5)
    {
        i = 0;
 
        std::cout << std::endl;
 
        return;
    }
 
    std::cout << x << "  ";
 
    ++i;
 
    rec_func_five_times(x + 1);
}
 
int main()
{
    rec_func_five_times(1);
    rec_func_five_times(2);
    rec_func_five_times(3);
 
    return 0;
}

Ob ob;
ob.f_0(); 
ob.f_1_rek(5)();

ob.rec_func_five_times (90);
ob.rec_func_five_times (89);

ob.rec_func_five_times (90);
ob.rec_func_five_times (89);
ob.rec_func_five_times (35);

#include <iostream>
 
class A {
 class B {;
  public:
   B ():i(0) {};
 
  private:
   int i;          
 };
 static B b;
};        
 
int main(){
    getchar ();
    return 0;
}

#include <iostream>
 
class Foo
{
public:
    void rec_method_five_times(int x)
    {
        static int i = 0;
 
        if (i == 5)
        {
            i = 0;
 
            std::cout << std::endl;
 
            return;
        }
 
        std::cout << x << "  ";
 
        ++i;
 
        rec_method_five_times(x + 1);
    }
};
 
int main()
{
    Foo bar;
 
    bar.rec_method_five_times(1);
    bar.rec_method_five_times(2);
    bar.rec_method_five_times(3);
 
    return 0;
}