Question

I have a need to serialize int, double, long, and float
into a character buffer and this is the way I currently do it

int value = 42;
char* data = new char[64];
std::sprintf(data, "%d", value);

// check
printf( "%s\n", data );

First I am not sure if this is the best way to do it but my immediate problem is determining the size of the buffer.
The number 64 in this case is purely arbitrary.
How can I know the exact size of the passed numeric so I can allocate exact memory; not more not less than is required?

Either a C or C++ solution is fine.

EDIT
Based on Johns answer ( allocate large enough buffer ..) below, I am thinking of doing this

char *data = 0;
int value = 42;
char buffer[999];
std::sprintf(buffer, "%d", value);
data = new char[strlen(buffer)+1];
memcpy(data,buffer,strlen(buffer)+1);

printf( "%s\n", data );

Avoids waste at a cost of speed perhaps. And does not entirely solve the potential overflow
Or could I just use the max value sufficient to represent the type.

Answer 1

In C++ you can use a string stream and stop worrying about the size of the buffer:

#include <sstream>

...

std::ostringstream os;
int value=42;
os<<42; // you use string streams as regular streams (cout, etc.)
std::string data = os.str(); // now data contains "42"

(If you want you can get a const char * from an std::string via the c_str() method)

---

In C, instead, you can use the snprintf to “fake” the write and get the size of the buffer to allocate; in facts, if you pass 0 as second argument of snprintf you can pass NULL as the target string and you get the characters that would have been written as the return value. So in C you can do:

int value = 42;
char * data;
size_t bufSize=snprintf(NULL, 0 "%d", value)+1; /* +1 for the NUL terminator */
data = malloc(bufSize);
if(data==NULL)
{
    // ... handle allocation failure ...
}
snprintf(data, bufSize, "%d", value);
// ...
free(data);