GUI_APP_MAIN
{
	Vector<int> v;
	v << 1 << 2 << 3;
	for(int& x: v)
		LOG(x);
}

GUI_APP_MAIN
{
	Vector<int> v;
	v << 1 << 2 << 3;
	for(auto& x: v)
		LOG(x);
}

Vector<int> range(int x, int y) {
	Vector<int> v;
	for(int i=x; i<=y; i++)
		v.Add(i);
	return v;
}

...

for(auto x: range(0, 10))
		arrayCtrl1.Add(x);

Vector<int> b=std:move(anotherVectorIntInstance); // move construction;

//or
Vector<int> b=anotherVectorIntInstance; //copy construction or deep copy, instead of
Vector<int> b(anotherVectorIntInstance, 0); // using dummy param to signal the intention of deep copy.

#include <iostream>
#include <string>
#include <algorithm>
#include <new>

using namespace std;

struct S
{
	S(){}
	S(const S& rhs) : text(rhs.text){}
	S(S&& rhs){
		struct T{ char _[sizeof(S)]; };
		std::swap(reinterpret_cast<T&>(*this), 
			reinterpret_cast<T&>(rhs)
		);
	}

	S& operator=(const S& rhs)
	{
		this->~S();
		return *new(this)S(rhs);
	}

	S& operator=(S&& rhs)
	{
		this->~S();
		// std::move() is necessary even when rhs is declared as temoprary
		return *new(this)S(move(rhs));
	}
	
	string text;
		
};
ostream& operator<<(ostream& os, const S& s)
{
	return os<<s.text<<endl;
}



S global;



int main()
{
	global.text="This is the global text";
	cout<<global;
	
	S a;
	a.text="This is object a";
	
	// 
	//
	S b(a);
	cout<<"after S b(a), now <b> is:"<<b<<"and <a> is:"<<a;
	
	S c(std::move(global)); // use move constructor
	cout<<"after S c=std::move(global), now <c> is:"<<c<<"and <global> is:"<<global;
	
}