#include<iostream>
#include<set>
#include<list>
using namespace std;


template<typename T>
void Display(const T& container)
{
	//typename T::const_iterator element;
	//for (element = container.cbegin(); element != container.cend(); ++element)
	for (auto element = container.cbegin(); element != container.cend(); ++element)
	{
		size_t pos = distance(container.cbegin(), element);
		cout << "[" << pos << "] = " << *element << endl;
	}
	cout << "SIZE = " << container.size() << endl;
	cout << "*****************" << endl;
}

//For set<int>...WORKS!!!
template<typename T>
//class SortDescend	//WORKS w class too!!!
struct SortDescend
{
	public:
	bool operator()(const T& lhs, const T& rhs) const
	{
		return (lhs > rhs);
	}
};

////For set<int>...DOES NOT WORK!!!
//template<typename T>
//	bool SortDescend(const T& lhs, const T& rhs)
//	{
//		return (lhs > rhs);
//	}


////For set<int>...DOES NOT WORK!!!
//template<typename T>
//	bool operator()(const T& lhs, const T& rhs) const
//	{
//		return (lhs > rhs);
//	}


//For list<int>...WORKS!!!
template<typename T>
bool SortDescendList(const T& lhs, const T& rhs)
{
	return (lhs > rhs);
}

////For list<int>...DOES NOT WORK with a struct!!!
//template<typename T>
//struct SortDescendList
//{
//	bool operator()(const T& lhs, const T& rhs) const
//	{
//		return (lhs > rhs);
//	}
//};

int main()
{
	//Auto sort ascending (no duplicates)
	set<int> s1{ 2,5,1,3,2,1,4 };	
	Display(s1);

	//WORKS!!!
	set<int, SortDescend<int>> s2(s1.cbegin(), s1.cend());	
	Display(s2);   

	//NOT WORK w binary predicate, need struct or class!!!
	//set<int, SortDescend<int>> s2(s1.cbegin(), s1.cend());	
	//Display(s2);   
	
	//NOT WORK w operator() directly, need struct or class!!!
	//set<int, operator()<int>> s2(s1.cbegin(), s1.cend());		
	//Display(s2);  

	//WORKS!!!  Auto sort ascending (duplicates)
	multiset<int> ms1{ 2,5,1,3,2,1,4 };
	Display(ms1);

	list<int> l1{ 2,5,1,3,2,1,4 };
	Display(l1);

	l1.sort(SortDescendList<int>);	//WORKS w function binary predicate obj
	//l1.sort(SortDescendList<int>);//NOT WORK w struct
	Display(l1);

	return 0;
}
/*
OUTPUT:
[0] = 1
[1] = 2
[2] = 3
[3] = 4
[4] = 5
SIZE = 5
*****************
[0] = 5
[1] = 4
[2] = 3
[3] = 2
[4] = 1
SIZE = 5
*****************
[0] = 1
[1] = 1
[2] = 2
[3] = 2
[4] = 3
[5] = 4
[6] = 5
SIZE = 7
*****************
[0] = 2
[1] = 5
[2] = 1
[3] = 3
[4] = 2
[5] = 1
[6] = 4
SIZE = 7
*****************
[0] = 5
[1] = 4
[2] = 3
[3] = 2
[4] = 2
[5] = 1
[6] = 1
SIZE = 7
*****************
*/

#include <iostream>
#include <vector>
using namespace std;

template <typename F>
void call_twice(F f)
{
	f();
	f();
}

void print()
{
	std::cout << "Hello!\n";
}

int main()
{
	call_twice(print);
	
	int x = 10;
	//call_twice([&x](){ std::cout << ++x << "\n"; });		//WORKS
	//call_twice([](){ std::cout << ++x << "\n"; });		//NOT WORK
	//call_twice(&x(){ std::cout << ++x << "\n"; });		//NOT WORK
	//call_twice((&x)(){ std::cout << ++x << "\n"; });		//NOT WORK
	//call_twice(*&x(){ std::cout << ++x << "\n"; });		//NOT WORK
	//call_twice((*(&x))(){ std::cout << ++x << "\n"; });	//NOT WORK
	
	int* px = &x;
	//call_twice(px(){ std::cout << ++x << "\n"; });		//NOT WORK
	//call_twice([px](){ std::cout << ++x << "\n"; });		//NOT WORK
	cout << "*px = " << *px << endl;
	
	return 0;
}

#include <functional>

void call_twice(std::function<void()> f)
{
	f();
	f();
}

//function pointer
#include <iostream>
using namespace std;
 
int mult(int a, int b) { return a * b; }
 
int main()
{
    int (*funcMult)(int, int);
 
    funcMult = mult;
 
    cout << "Product: " << funcMult(11, 5) << endl;
    
    //Without ever looking, I thought it might be done this way (since can have overloaded functions)
    //mult(int, int)* pMult = mult(int, int);	//NOT WORK!!!
 
    return 0;
}

#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;

template<typename T>
void Display(const T& c)
{
	for (auto iter = c.cbegin(); iter != c.cend(); ++iter)
		std::cout << *iter << std::endl;

}

int main()
{
        vector<char> v1{ 'A', 'b', 'C', 'd' };
	//transform(v1.begin(), v1.end(), v1.begin(), ::toupper);	//WORKS!
	//transform(v1.begin(), v1.end(), v1.begin(), toupper);	//WORKS!
	transform(v1.begin(), v1.end(), v1.begin(), std::toupper);	//WORKS!
	Display(v1);

	toupper;		//Works!
	::toupper;		//Works!
	std::toupper;	//Works!
	::cout;		//Works!
	cout << ::endl; //Works!

	return 0;
}

#include <set>
#include <vector>
#include <iostream>

int main() {
	const std::set s {1, 2, 3, 4};
	const std::vector v { 'a', 'b', 'c'};

	for (const auto a : s)
		std::cout << a << ' ';

	std::cout << '\n';

	for (const auto a : v)
		std::cout << a << ' ';

	std::cout << '\n';
}