#include <string>
#include <boost/lexical_cast.hpp>

// ...

std::string text = boost::lexical_cast<std::string>(lscore);
lscore_spr = TTF_RenderText_Solid(font, text.c_str(), textColor);

#include <string>
#include <sstream>

// ...

std::stringstream stream;
stream << lscore;
std::string text = stream.str();
lscore_spr = TTF_RenderText_Solid(font, text.c_str(), textColor);

//render scores
//left
stream << lscore;
text = stream.str();
lscore_spr = TTF_RenderText_Solid(font, text.c_str(), textColor);
text.c_str() = "";
//right
stream << rscore;
text = stream.str();
rscore_spr = TTF_RenderText_Solid(font, text.c_str(), textColor);
text.c_str() = "";

draww(40,40,lscore_spr,screen);
draww(40,600,rscore_spr,screen);

0
00
000
0000
00000
000000
0000000
00000000

std::string toString(int number)
{
    std::stringstream stream;
    stream << number;
    return stream.str();
}

SDL_Surface *renderNumber(TTF_Font *font, int number, SDL_Color colour)
{
    return TTF_RenderText_Solid(font, toString(number).c_str(), colour);
}

// ...

lscore_spr = renderNumber(font, lscore, textColor);
rscore_spr = renderNumber(font, rscore, textColor);

// ...

char buf[80];
sprintf( buf, "%d", number );

#include <climits>

// Make *_MAX available for template code.
template <typename T> struct get_val_max;
template <> struct get_val_max<char> { enum { value = CHAR_MAX }; };
template <> struct get_val_max<signed char> { enum { value = SCHAR_MAX }; };
template <> struct get_val_max<unsigned char> { enum { value = UCHAR_MAX }; };
template <> struct get_val_max<short> { enum { value = SHRT_MAX }; };
template <> struct get_val_max<unsigned short> { enum { value = USHRT_MAX }; };
template <> struct get_val_max<int> { enum { value = INT_MAX }; };
template <> struct get_val_max<unsigned int> { enum { value = UINT_MAX }; };
template <> struct get_val_max<long> { enum { value = LONG_MAX }; };
template <> struct get_val_max<unsigned long> { enum { value = ULONG_MAX }; };
#ifdef LLONG_MAX
template <> struct get_val_max<long long> { enum { value = LLONG_MAX }; };
template <> struct get_val_max<unsigned long long> { enum { value = ULLONG_MAX }; };
#endif

// Check signedness of a type.
template <typename T> struct is_signed { enum { value = 1 }; };
template <> struct is_signed <char> { enum { value = CHAR_MIN < 0 }; };
template <> struct is_signed <unsigned char> { enum { value = 0 }; };
template <> struct is_signed <unsigned short> { enum { value = 0 }; };
template <> struct is_signed <unsigned int> { enum { value = 0 }; };
template <> struct is_signed <unsigned long> { enum { value = 0 }; };
#ifdef LLONG_MAX
template <> struct is_signed <unsigned long long> { enum { value = 0 }; };
#endif

// Recurse and divide by base until zero is reached
template <typename T, T base, T val, bool recurse=val!=0>
struct get_dig_max_rec {
        enum { value = 1 + get_dig_max_rec<T, base, val/base>::value };
};
template <typename T, T base, T val> struct get_dig_max_rec<T,base,val,false> {
        enum { value = 0 };
};

// Get number of digits needed to represent any value of T in base
template <typename T, int base> struct get_dig_max {
        enum {
                value = is_signed<T>::value
                      + get_dig_max_rec<T, base, get_val_max<T>::value>::value
        };
};

// some typedefs
template <typename T> struct get_base10_dig_max : get_dig_max<T,10> {};
template <typename T> struct get_base16_dig_max : get_dig_max<T,16> {};
template <typename T> struct get_base2_dig_max : get_dig_max<T,2> {};

#include <iostream>
int main () {
        std::cout << get_base10_dig_max<char>::value << '\n';
        std::cout << get_base10_dig_max<signed char>::value << '\n';
        std::cout << get_base10_dig_max<unsigned char>::value << '\n';
        std::cout << get_base10_dig_max<unsigned int>::value << '\n';
        std::cout << get_base10_dig_max<int>::value << '\n';
        // etc.
}

char buf[get_base10_dig_max<int>::value + 1];

char buf[get_base10_dig_max<decltype(your_var)>::value + 1];

class ScoreText {
public:
	ScoreText(int x, int y, TTF_Font * font, SDL_Color color)
		: current_score(0)
		, font(font)
		, cache(NULL)
		, color(color)
	{
		dst.x = x;
		dst.y = y;
	}

	~ScoreText() {
		clear_cache();		
	}
	void update(int new_score) {
		if (current_score == new_score) return;
		current_score = new_score;
		clear_cache();
	}
	void set_position(int x, int y) {
		dst.x = x;
		dst.y = y;
	}
	bool render(SDL_Surface * s) {
		SDL_Surface * text = get_cached();
		if (text != NULL) {
			int result = SDL_BlitSurface(text, NULL, s, &dest);
			if (result == -2) clear_cache();
		}
		return result == 0;
	}
private:
	void clear_cache() {
		if (cache != NULL) SDL_FreeSurface(cache);
		cache = NULL;
	}
	SDL_Surface * get_cached() {
		if (cache == NULL) {
			char buf[40];
			sprintf(buf, "%d", current_score);
			cache = TTF_RenderText_Solid(font, buf, color);
		}
		return cache;
	}
	int current_score;
	SDL_Rect dest;
	SDL_Surface * cache;
	SDL_Color color;
};