#include <iostream>

class OuterClass
{
public:
OuterClass()
{
	std::cout << "OuterClass Constructor" << std::endl;
}
~OuterClass()
{
	std::cout << "OuterClass Destructor" << std::endl;
}
OuterClass(const OuterClass & rhs)
{
	std::cout << "OuterClass Copy" << std::endl;
}
OuterClass & operator=(const OuterClass & rhs)
{
	std::cout << "OuterClass Assignment" << std::endl;
}

class InnerClass
{
public:
	InnerClass() : m_int(0)
	{
		std::cout << "InnerClass Constructor" << std::endl;
	}
	InnerClass(const InnerClass & rhs) : m_int(rhs.m_int)
	{
		std::cout << "InnerClass Copy" << std::endl;
	}
	InnerClass & operator=(const InnerClass & rhs)
	{
		std::cout << "InnerClass Assignment" << std::endl;
		m_int = rhs.m_int;
		return *this;
	}
	~InnerClass()
	{
		std::cout << "InnerClass Destructor" << std::endl;
	}
	void sayHello()
	{
		std::cout << "Hello!" << std::endl;
	}

private:
	int m_int;
};

InnerClass innerClass()
{
	InnerClass ic;
	std::cout << "innerClass() method" << std::endl;
	return ic;
}
};

#include "innerclass.hpp"

int main(void)
{
std::cout << std::endl << "1st try:" << std::endl;


OuterClass oc;
OuterClass oc2(oc);
oc.innerClass().sayHello();

std::cout << std::endl << "2nd try:" << std::endl;

OuterClass::InnerClass ic(oc.innerClass());
ic = oc.innerClass();
}

1st try:
 OuterClass Constructor
 OuterClass Copy
 InnerClass Constructor
 innerClass() method
 Hello!
 InnerClass Destructor

 2nd try:
 InnerClass Constructor
 innerClass() method
 InnerClass Constructor
 innerClass() method
 InnerClass Assignment
 InnerClass Destructor
 InnerClass Destructor
 OuterClass Destructor
 OuterClass Destructor

InnerClass innerClass() {
    InnerClass ic;
    std::cout << "innerClass() method" << std::endl;
    return ic;    // this might not call copy ctor
}

Object SomeFunc() {
  Object o1 = ...
  return Object(o1);
}

OuterClass(const OuterClass & rhs)
{
std::cout << "OuterClass Constructor" << std::endl;
==>
std::cout << "OuterClass Copy Constructor" << std::endl;

}

OuterClass & operator=(const OuterClass & rhs)
{
 std::cout << "OuterClass Constructor" << std::endl;
==>
 std::cout << "OuterClass Assignment operator" << std::endl;
}

InnerClass innerClass()
{
    InnerClass ic;
     std::cout << "innerClass() method" << std::endl;
   return ic;
}

void innerClass( InnerClass &namedResult)

{
std::cout << "innerClass() method" << std::endl;

 }

MyObject(const MyObject&)

MyObject m1;
MyObject m2(m1);