How to parse a const char* from a double / long without the std::string library?

Question

How can I parse a const char* from a double or long?

Mainly because my code is a lot faster when I use a const char*, so i decided to create a small base string class. But my code to parse a double has some bugs.

My code only works partially. Some help would be very appreciated. I am using macos, g++ & c++17.

Code:

#include <iostream>
class bstring {
public:
    const char* characters;
    bstring(const char* c = "") { characters = c; }
    static bstring parse(const double number, int precision = 100) {

        // Convert.
        int     decimal,   sign;
        char    *buffer;
        buffer = ecvt(number, precision, &decimal, &sign);
        int n = strlen(buffer);

        // Add decimal.
        char before[decimal];
        strncpy(before, 0 + buffer, decimal);
        char after[n - decimal - 1];
        strncpy(after, decimal + buffer, n - decimal - 1);

        // Remove zero padding.
        int removed = 0;
        while (true) {
            size_t n = sizeof(after) - removed;
            size_t index_to_remove = n - 1;
            if (after[index_to_remove] == '0') {
                for (size_t i = index_to_remove; i < n - 1; ++i) { 
                    after[i] = after[i + 1]; 
                }
                removed += 1;
            } else { break; }
        }
        bool is_zero = removed == sizeof(after);
        int after_size = sizeof(after)-removed;
        char* nafter = (char*)malloc(sizeof(char) * after_size);

        // Concat.
        char* new__{ new char[strlen(before) + 1 + after_size] };
        new__ = strcpy(new__, before);
        new__ = strcat(new__, "."); 
        if (is_zero)  {
            char a[] = "0";
            new__ = strcat(new__, a);   
        } else {
            new__ = strcat(new__, after);   
        }

        // Assign.
        bstring s = new__;
        delete[] new__; new__ = NULL;
        return s;

        // 
    }
};
std::ostream& operator <<(std::ostream &s, bstring x) { return s << x.characters; }
int main() {
    std::cout << "Should be " << "-1234.39950" << ": " << bstring::parse(-1234.39950) << std::endl;
    std::cout << "Should be " << "-1.0" << ": " << bstring::parse(-1.0) << std::endl;
    std::cout << "Should be " <<"0.0" << ": " << bstring::parse(0.0) << std::endl;
    std::cout << "Should be " <<"0.3897495" << ": " << bstring::parse(0.3897495) << std::endl;
    std::cout << "Should be " <<"1.0" << ": " << bstring::parse(1.0) << std::endl;
    std::cout << "Should be " <<"100.00" << ": " << bstring::parse(1000.0) << std::endl;
    std::cout << "Should be " <<"10000.000" << ": " << bstring::parse(1000000.0) << std::endl;
    std::cout << "Should be " <<"1000000.0000" << ": " << bstring::parse(1000000000.0) << std::endl;
    std::cout << "Should be " <<"1000000000.0000" << ": " << bstring::parse(1000000000000.0) << std::endl;
    std::cout << "Should be " <<"1000000000000.0000" << ": " << bstring::parse(1000000000000000.0) << std::endl;
}

Edit:

Is this piece of code okay? Or am I doing something wrong by not deleting it / By where I assign the new__ to.

// Concat.
    bstring concat(const char* c) {
        int n = ::strlen(characters) + ::strlen(c);
        if (n == 0) { return bstring(); }
        if (::strlen(c) == 0) { return bstring(characters); }
        char* new__{ new char[n + 1] };
        new__ = strcpy(new__, characters);
        new__ = strcat(new__, c);   
        // const char* n = new__;
        // delete[] new__; new__ = NULL;
        bstring s = new__;
        return s;
    }