TUTORIALUnfinished C++11 'guide'-ish

const int* ptr;

*ptr = 5

int x = 5;
int& xx = x;
const int& xxx = xx;
const int xxxx = x;

auto y = x;
// The type of'y' is equal to int
// Type deduction looks at the declaration of 'x' and determines it is a int.

auto yy = xx; 
// The type of 'yy' is equal to int.
// Notice how using auto on a type of T& only 
// the type T. This is very usefull because alot of the 
// you want yy to get copied instead of using its 
// However you can still easily make it a reference by doing auto&.

auto yyy = xxx; 
// Type of 'xxx' is equal to 
// The deduction of const T& only 
// the type T. (Its constness is 
// The method to make it a reference is still the same.

auto yyyy = xxxx; 
// Type of 'yyyy' is equal to int. (Notice how the consness is removed)

auto& xy = xxxx; 
// Type of 'xy' is equal to const 
// Notice how the consness is kept, 
// the rules of const is taking over, you cannot create 
// non-const reference to a const type (Unless using const_cast which is a whole other discussion).

int x = 5;
int* xx = &x;
const int* xxx = xx;

auto v1 = x; 
// v1 = int (Auto deduction is int.)

const auto& v2 = xx; 
// v2 = int*const& (A reference to a pointer that points to a const 
// auto deduction = int*

auto v3 = xxx; 
// v3 = const int* (A pointer to a const 
// Notice that the pointer points to a const int, the 
// is not const, its what it points to. (Meaning you can assign the pointer to a new ptr)


const auto* const v4 = v3; 
// v4 = const int* const (A const pointer to a const 
// auto deduction = const 
// now the pointer is const, you can no longer change the address it points to.

// When using auto for parameters the constness of the parameters
// is ignored if the parameters is a pointer, however if it is a reference 
// the constness over rules.
// e.g:

(const* int param1, const int* const param2, const int& param3)
{
        auto v1 = param1; // v1 = const int*
    auto v2 = param2; // v2 = const int* (param2's constness ignored)
    auto v3 = param3; // v3 = int (Constness & referenceness is ignored)
    auto& v4 = param3; // v4 = const int&
}

// Create a stl vector of size 15
std::vector<int> vec{ 15 };

// An example of minimizing loop code greatly
// is this:
for (auto it = vec.begin(); it != vec.end(); ++it)
    *it = rand();

// Instead of:
for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it);

decltype(auto) x = y; 
// y = int. x would be = int&
// Whilst using auto x would = int.

// This will cause some problems if you dont know the rules,
// this could messup a whole program if you do this in a library you create or similiar.

auto lookupValue(const int& lookingfor)
{
      auto vector = getVector();
      // Do some computing to find the value you are looking for...    
      return vector[idx]; // Returns the value that it compared to
}

decltype(auto) get(const int& idx)
{
    auto vector = getVector();
    return vector[idx];
}

int x = 5; // Lvalue, stored untill the end of the current scope
int y = 7; // Same as 'x'
&x; // Totally valid line.
&y; // Same

x + y; // Rvalue, the result of x + y gets destroyed at the semicolon.
x + y = 10; // Invalid line, rvalue on the left hand side of an assignment.
int z = x + y; // Valid, rvalue on the right hand sife of an assignment.
45; // Rvalue, gets destroyed at semicolon.

Foo v1;
Foo v2(v1); // Copy constructor is called (Foo(const Foo& other))
Foo v3(std::move(v1)); // Move constructor is called (Foo(Foo&& other))
// When v1 reaches the semicolon it will be destructed, but before its destructed
// the contents of v3 is swapped with v1, meaning v3 holds everything v1 held.

// in class Foo
Foo(Foo&& other)
{
     // Now we just neatly swap the items in other with our own.
     std::swap(_resources, other._resources); 
}

template<typename _T>
void Add( _T&& element ) // when calling this function you should NOT do obj->Add<type> because 
// perfect forwarding relies on type deduction using universal references (typename of name T with && becomes a
// universal reference)
{
   // Now universal references can be lvalues or rvalues (see where I'm getting?)
   _vec.push_back( std::forward<_T>(element) );
}