#include <iostream>

using namespace std;

template <typename Type>
const Type& GetMax(const Type& val1, const Type& val2)
{
	if (val1 > val2)
		return val1;
	else
		return val2;
}

template<typename Type>
void DisplayComparison(const Type& val1, const Type& val2)
{
	cout << "Max of (" << val1 << ", " << val2 << ") = " << GetMax(val1, val2) << endl;

}

int main()
{
	//Test 1
	string name1("Jack"), name2("John");
	DisplayComparison(name1, name2);

	//Test 2
	DisplayComparison("Jack", "John");
	//prints "Jack" if Test 1 is commented out
	//Prints "John" if Test 1 is NOT commented out

	//Test3
	DisplayComparison<string> ("Jack", "John");


	//Test 4 (ASCII  H = 72,  J = 74)
	DisplayComparison("H", "J");	//prints 'H'???
	DisplayComparison("J", "H");	//prints 'H'???
	
	char char1 = 'H';	//ASCII  72
	char char2 = 'J';	//ASCII  74
	DisplayComparison(char1, char2);	//prints 'J'
	DisplayComparison(char2, char1);	//prints 'J'



	cout << "*****************************\n\n";

	if (char1 > char2)
		cout << "Char1 is greater\n";
	else
		cout << "Char1 is less\n";
	cout << endl;


	//	DisplayComparison(10, 20);
	//	DisplayComparison(3.14, 3.1415);
	return 0;
}

#include <iostream>

template < typename T > void foo( const T&, const T& ) { std::cout << "base template\n" ; }

template <> void foo( const char* const&, const char* const& ) { std::cout << "specialisation for T == const char*\n" ; }

int main()
{
    foo( 22, 33 ) ; // base template T == int

    foo( "abcd", "efgh" ) ; // base template T == const char[5]

    // foo( "abcd", "efghijkl" ) ; // *** error: no matching function; 
                                   //            conflicting types foo( const char[5], const char[9] ) 

    char cstr1[] = "abcd", cstr2[] = "efgh" ;
    foo( cstr1, cstr2 ) ; // base template T == const char[5];

    char* p1 = cstr1, *p2 = cstr2 ;
    foo( p1, p2 ) ; // base template T == char*

    const char* pc1 = p1, *pc2 = p2 ;
    foo( pc1, pc2 ) ;

    // foo( pc1, p2 ) ; // *** error: no matching function: 
                        //     conflicting types foo( const char*, char* )

    foo<const char*>(p1,p2) ; // specialisation for T == const char*
    foo<const char*>(pc1,p2) ; // specialisation for T == const char*
    foo<const char*>(pc1,"xyz") ; // specialisation for T == const char*
}

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

int main()
{
	string str1("Hello_World on day 1! What a time to be alive today!");

	//THIS WORKS!!! Find first "day"
	size_t charPos = str1.find("day", 0);
	if (charPos != string::npos)
	{
		cout << "day found at pos = " << charPos << endl << endl;
	}
	else
		cout << "NOT FOUND!\n\n";
	

	//THIS WORKS!!! Find all "day" matches
	charPos = str1.find("day", 0);
	while (charPos != string::npos)
	{
		cout << "day found at pos = " << charPos << endl;
		charPos = str1.find("day", charPos + 1);
	}
	cout << endl << endl;


	//DOES NOT WORK!!!
	//string::iterator findChar;
	string::const_iterator findChar;
	findChar = find(str1.begin(), str1.end(), "day");

	if (findChar != str1.cend())
	{ 
		cout << "day found at pos = " << distance(str1.cbegin(), findChar) << endl;
	}
	cout << "NOT FOUND!\n\n";
	
	
	//THIS WORKS!!!
	vector<int> myInt{ 10,20,30,40,50 };
	vector<int>::const_iterator iter30 = find(myInt.cbegin(), myInt.cend(), 30);

	if (iter30 != myInt.cend())
		cout << "30 found at pos = " << distance(myInt.cbegin(), iter30) << endl << endl;
	else
		cout << "30 NOT FOUND!!!\n\n";



	return 0;
}

#include <string_view>
#include <algorithm>
#include <iostream>

using namespace std::string_view_literals;

int main() {
	constexpr std::string_view tofind { "day" };
	constexpr std::string_view str1 { "Hello_World on day 1! What a time to be alive today!" };

	const auto findChar { std::search(str1.cbegin(), str1.cend(), tofind.cbegin(), tofind.cend()) };

	const auto rangeChar { std::ranges::search(str1, "day"sv) };

	if (findChar != str1.cend())
		std::cout << "day found at pos = " << std::distance(str1.cbegin(), findChar) << '\n';
	else
		std::cout << "NOT FOUND!\n\n";

	if (!rangeChar.empty())
		std::cout << "day found at pos = " << std::distance(str1.cbegin(), rangeChar.begin()) << '\n';
	else
		std::cout << "NOT FOUND!\n\n";

}

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
	const std::vector myVec { 10, 20, 30, 40, 50, 60 };
	const auto iter { myVec.cbegin() + 5 };

	std::cout << *iter << "\n\n";

	std::vector<int> partialCopy { myVec.cbegin(), iter }; //copy 1st 5

	for (auto i : partialCopy)
		std::cout << i << '\n';
}

#include <vector>
#include <iostream>
#include <algorithm>
#include <string>

int main() {
	const std::string foobar { "foobar" };

	for (auto itr { foobar.cbegin() }; itr != foobar.cend(); ++itr)
		std::cout << static_cast<unsigned int>(*itr) << "  ";
}