String class : inherited from basic_string

#include <cassert>
#include <sstream>
#include <cctype>
#include <cmath>
#include <algorithm>
#include <iostream>

//Extends std::basic_string and adds more functionality
class String : public std::basic_string<char>
{
public:
	typedef std::basic_string<char> string_type;
public:	
	String() : string_type() {}
	String(const char * str) : string_type(str){}
	String(const char * str, size_t n) : string_type(str,n) {}
	String(size_t n , char c ) : string_type(n,c) {}
public:
	//added functionalities
	String  toUpper()const      { return _apply(std::toupper);  }
	String  toLower()const      { return _apply(std::tolower);  }
	
	bool    isDigits()const     { return _isAllDigits();	}
	bool    isLower()const      { return _checkIf(std::islower);}
	bool    isUpper()const      { return _checkIf(std::isupper);}
	bool    isAlpha()const      { return _checkIf(std::isalpha);}

	int     toInt()	const       { return _convertTo<int>(*this);}		
	long    toLong()const       { return _convertTo<long>(*this);}	
	float   toFloat()const      { return _convertTo<float>(*this);}
	double  toDouble()const     { return _convertTo<double>(*this);}		
	size_t  toSizeT()const      { return _convertTo<size_t>(*this);}

	void    reset()             { *this = String();	}

	bool    startsWith(const String& preFix)const {
				return substr(0,preFix.size()) == preFix; 
			}
	bool    endsWith(const String& suffix)const	{
				return substr(size()-suffix.size()) == suffix; 
			}
	
	void    shuffleIt() {
				std::random_shuffle( begin(), end()); 
			}
	
	String  shuffled()const{
				String tmp = *this;
				tmp.shuffleIt();
				return tmp; 
			}
	//conversion function
	operator const char*(){
		return c_str();
	}
private:
	//helpers
	typedef int(*ApplyFunc)(int); 	
	//converts a string to a valid data type
	template<typename ReturnType>
	ReturnType _convertTo(const String& str)const{			
		_assertValidSize();
		std::stringstream convert;
		convert << str ;
		ReturnType data;
		assert(!(convert >> data).fail() ); //make sure conversion was succesful
		return data;
	}

	//takes in a function and returns a string with that function applied to the whole string
	String _apply(const ApplyFunc& Applier )const{
		_assertValidSize();
		String str;
		std::transform( begin(),end(), //from start to end
						std::back_insert_iterator<string_type>(str), //adjust str size
						Applier); //while applying a function to it
		return str;
	}	

	//takes in a function and checks if it passes the function checking
	bool _checkIf(const ApplyFunc& Applier)const{
		for(size_t indx = 0; indx != size(); ++indx){			
			if(!Applier((*this)[indx]) )return false;
		}
		return true;
	}
	//A valid digit is 0-9, with the expection of '.' for floating point, and '-' for negative digits
	//A valid here cannot end with any post-fix, ex : 3.14f or 124L is invalid!
	bool _isAllDigits()const{
		size_t start = 0;
		if((*this)[0] == '-' ) 
			start = 1;
		for(; start < size(); ++start){
			char value = (*this)[start];
			if(!isdigit( value ) && value != '.' )
				return false;
		}
		return true;
	}
	void _assertValidSize()const{
		assert(size());
	}	
};
int main ()
{	

	using namespace std;

	String str("StRinG");		
	
	cout << str.toUpper().shuffled() << endl;


	return 0;
}