need a c-string format of toString()

If you just need to convert the output of toString(), you can use

const char* s = toString().c_str();

Note that c_str simply returns a pointer to the underlying character storage of the string. So you do need to be careful to not get a pointer to the string and then having that string go out of scope, in which case the pointer may or may not still point to valid memory. Your function currently is returning a string (I'm guessing your code has using namespace std) which means a C++ string object.

If you don't absolutely need C strings, I would recommend using C++ strings, since they are more current and just easier to work with. However, if for reasons somewhere else in the code you do need a C string, your function should look like

char* toString() {
    // formatting your output
}

Because all a C string is is a null terminated ('\0') array of char, and an array is equivalent to a pointer to the first element, so that's where char* comes from.

Because of that, something needs to “own” the memory of that character array, and that something needs to have a “lifetime” that is at least as long as the scope you need it for. If you make a function that returns a raw char * you should make sure that the pointer is to either a:

• static string literal
• a dynamically allocated string with the new operator that you then make sure to delete later.

In either case, C++ stringstreams could make formatting your output far more intuitive. You will need #include <sstream> and then some googling will steer you in the right direction. This solution also works if you need a C string, because C++ strings have a method called c_str() that converts C++ strings into C strings (null terminated array of characters):

#include <string>
#include <sstream>
using namespace std;

string toString() {
    stringstream ss; // these are so useful!
    if (*d != 1) {
        // this probably isn't the exact formatting you are looking for,
        // but stringstreams can certainly do it if you research a bit!
        ss << *n << *d;
    }
    else {
        ss << *n;
    }
    return ss.str();
}

void function_that_needs_c_string(const char * c);

int main() {
    function_that_needs_c_string(toString().c_str());
}

Because in a format string, the # is used to signify an optional character placeholder; it's only used if needed to represent the number.

If you do this instead: 0.ToString("0.##"); you get: 0

Interestingly, if you do this: 0.ToString("#.0#"); you get: .0

If you want all three digits: 0.ToString("0.00"); produces: 0.00

More here

Use sprintf. (This is NOT safe, but OP asked for an ANSI C answer. See the comments for a safe version.)

int sprintf ( char * str, const char * format, ... );

Write formatted data to string Composes a string with the same text that would be printed if format was used on printf, but instead of being printed, the content is stored as a C string in the buffer pointed by str.

The size of the buffer should be large enough to contain the entire resulting string (see snprintf for a safer version).

A terminating null character is automatically appended after the content.

After the format parameter, the function expects at least as many additional arguments as needed for format.

Parameters:

str

Pointer to a buffer where the resulting C-string is stored. The buffer should be large enough to contain the resulting string.

format

C string that contains a format string that follows the same specifications as format in printf (see printf for details).

... (additional arguments)

Depending on the format string, the function may expect a sequence of additional arguments, each containing a value to be used to replace a format specifier in the format string (or a pointer to a storage location, for n). There should be at least as many of these arguments as the number of values specified in the format specifiers. Additional arguments are ignored by the function.

Example:

// Allocates storage
char *hello_world = (char*)malloc(13 * sizeof(char));
// Prints "Hello world!" on hello_world
sprintf(hello_world, "%s %s!", "Hello", "world");