Welcome to the Lounge

Ruffnik wrote:

it attracts a certain kind of people and that certain kind of people keep C the way it is.

 #include <iostream>
 #include <string>
 #include <algorithm> // For std::remove_if

// Function to remove thousands separators from a formatted number
std::string removeThousandsSeparators(const std::string& formattedNumber) 
{
    std::string result = formattedNumber;

    // Remove any non-digit characters (e.g., commas)
    result.erase(std::remove_if(result.begin(), result.end(),  {
        return !std::isdigit(c);
    }), result.end());

    return result;
 }

int main() 
{
    // Example usage
    std::string formattedInput = "1,234,567"; // Input with thousands separators
    std::string strippedNumber = removeThousandsSeparators(formattedInput);

    std::cout << "Formatted input: " << formattedInput << std::endl;
    std::cout << "Stripped input: " << strippedInput << std::endl;

    return 0;
}

// Macro to stringify an argument
 #define STRINGIZE(x) #x

auto strippedNumber = removeThousandsSeparators(STRINGIZE(1,234,567));

Stacy Dudovitz wrote:

So, curious question... even if you are trafficking in .c files, why aren't you using a C++ compiler to compile your C code?

Stacy Dudovitz wrote:

Here is an example of how it might be used:

Stacy Dudovitz wrote:

Keep in mind, all of this is done at compile time, so there is no performance penalty.

Stacy Dudovitz wrote:

When there's a will, there's a relative.

honey the codewitch wrote:

considering taking a different approach - ground up rewrite, heavy on the copy and paste from the old codebase.

The "common code" was a huge DLL that took forever to load and it contained code that was only occasionally used.

My boss, who learned to program in the Navy over twenty years earlier, was one of the programmers who originally built the program. While he was a good programmer, he moved into management and his skills became very rusty and out of date. He could not see why the existing code had to be changed.

This left me with the dilemma: update it on my own time without telling him or try to patch the code and pray that nothing breaks irrevocably.

I came up with a plan:

1. I dropped the duplicate subroutines and functions, then recoded the calls to use the ones that remained. I hunted down all of the dependencies upon side effects and removed them. Many were functions that returned a single value of True or False, but modified other data. These I changed to return a data record with the data changes. I released this update to the huge common code DLL.
   
2. I split the common code DLL into a three level structure with all the non-UI Windows API calls in the bottom layer. Depreciated API calls, of which there were many, were replaced with the current ones. The code to set up for API calls, such as letter generation, print formatting, data base record construction and whatnot in the middle layer as multiple DLLs. The top layer contained the business logic, with separate DLLs for Mental Behavioral Health, Mental Retardation Developmental Disabilities, insurance processing, billing, and client demographics. I released this revised common code as an update. I received praise from the clinicians because the whole program loaded much faster. My boss provided no feedback.
   
3. I split the main UI code removing rarely used paths to separately called programs. The main UI code handled all of the windows that everyone used. The separate programs handled billing and report generation, behavioral health unique logic, and developmental disabilities unique logic. I released this in stages, and again the loading time decreased.
   
4. When my boss decided on a date to update to Windows 7, he asked (finally!) how long it would take to convert the code base. I told him that, with the recent updates currently in place, I could be ready in two weeks.
   

While the cutover was ongoing, I did have to maintain two versions of the bottom layer of DLLs, but that was not overly onerous. The field crew could reinstall the final version with a simple command line.

The whole thing went so smoothly, that my boss was amazed. He finally looked through the code and was instantly lost when he found the code for loading and running multiple independent modules. He blew a gasket - his and his buddy's "elegant solution," which had morphed into spaghetti code was almost totally gone, although most of their code remained. He could not do much to me at the time: I was the clinicians' hero.

When I was asked (not by my boss!), I told people I was hired by my boss' predecessor as a software engineer, not just as a programmer.