Quote:Original post by jykQuote:This may be useful: itoa()Is there any particular reason you would recommend itoa() over the previous suggestions, lexical_cast and stringstream? (Note that itoa() is non-standard, and may not even be available to the OP.)
Quote:Original post by stephe
I didnt say it is better. I think effect is same and easy to use, if available.. in every way, you are right, itoa() is non standard
char * itoa(int, char *, int); // you supply the bufferchar * itoa(int, int, char *); // you supply the bufferchar * itoa(int, char *); // you supply the bufferchar * itoa(int, int); // you need to free the pointerchar * itoa(int); // you need to free the pointervoid itoa(int input, void (*subr)(char))
stringstream myString;myString << someInteger;myString.str().c_str();Quote:Original post by leeor_net
I haven't seen this suggested but this may be too simple:stringstream myString;myString << someInteger;myString.str().c_str();
Quote:Original post by dj3hut1
Hello Lith,
you can also use sprintf ( from <cstdio> ).char buf[80];sprintf( buf, "%d", number );
Quote:Original post by phresnelQuote:Original post by dj3hut1
Hello Lith,
you can also use sprintf ( from <cstdio> ).char buf[80];sprintf( buf, "%d", number );
Possible undefined behaviour if a compiler defines an int to be 34 or more bytes long. Because of that, we use sooner mentioned methods in C++.
Quote:Original post by dclydeQuote:Original post by phresnelQuote:Original post by dj3hut1
Hello Lith,
you can also use sprintf ( from <cstdio> ).char buf[80];sprintf( buf, "%d", number );
Possible undefined behaviour if a compiler defines an int to be 34 or more bytes long. Because of that, we use sooner mentioned methods in C++.
Which when it comes down to it that implementation ends up using sprintf or sprintf_s just with a little bit of a smarter buffer size declaration somehow relative to _MAX_INT_DIG from yvals.h
#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_MAXtemplate <> 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_MAXtemplate <> struct is_signed <unsigned long long> { enum { value = 0 }; };#endif// Recurse and divide by base until zero is reachedtemplate <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 basetemplate <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 typedefstemplate <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];Quote:Original post by mattd
I think you got the is_signed specializations for unsigned types the wrong way around.
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;};
