3
\$\begingroup\$

Because I don't want to download an entire library for a single function (which I do understand, was made better than I made mine), I decided to implement my own string formatting function.

I am not very proud of it, as I find it pretty ugly and unreadable.
This is only a string formatter with string-only arguments.
Efficiency is not a concern for me.

#include<iostream>
#include<unordered_map>
#include<string>

using std::string;
string formatString(string format, const std::unordered_map<string, string>& args) {
    string ret;

    string::size_type bracketLoc;
    while((bracketLoc = format.find_first_of('{')) != string::npos) {
        // Handling the escape character.
        if(bracketLoc > 0 && format[bracketLoc - 1] == '\\') {
            ret += format.substr(0, bracketLoc + 1);
            format = format.substr(bracketLoc + 1);
            continue;
        }

        ret += format.substr(0, bracketLoc);
        format = format.substr(bracketLoc + 1);

        bracketLoc = format.find_first_of('}');
        string arg = format.substr(0, bracketLoc);
        format = format.substr(bracketLoc + 1);

        auto it = args.find(arg);
        if(it == args.end()) {
            ret += "(nil)";
        } else {
            ret += it->second;
        }
    }

    ret += format;

    return ret;
}

int main() {
    std::cout << formatString("Hello, {Name}! {WeatherType} weather, right?", {
        {"Name", "Midnightas"},
        {"Fruit", "Apple"}
    });

    return 0;
}

Compile with -std=c++11.
The above program will output Hello, Midnightas! (nil) weather, right?.

\$\endgroup\$
  • \$\begingroup\$ No worries, it started out fine, but now it's great. Please try to keep roughly the same format when you'll post new questions. On the more technical note, you might want to have a look at my answer to another post, as well as fmtlib, which seems to be on its way into standard. \$\endgroup\$ – Incomputable May 26 '18 at 16:36
  • \$\begingroup\$ Yeah, that's the "entire library" that I meant, and I'm not really planning on using versions newer than C++11 as it's standard library does enough for me (Except for this). \$\endgroup\$ – mid May 26 '18 at 16:40
  • \$\begingroup\$ I don't understand how you arrived at the conclusion that the standard library can't do this. Maybe it's an issue of terminology. Maybe you mean to implement a string templating feature. Because both C and C++ can definitely already format strings. \$\endgroup\$ – Reinderien May 26 '18 at 16:58
  • \$\begingroup\$ @Reinderien I made this because the standard library doesn't support named arguments afaik. \$\endgroup\$ – mid May 26 '18 at 17:03
  • \$\begingroup\$ Most libraries use positional rather than named overloads. ie "This is %2 of %1\n", where %2 is replaced with the second argument and %1 is replaced with the first argument. Not sure if named arguments helps that much. \$\endgroup\$ – Martin York May 26 '18 at 17:25
3
\$\begingroup\$
  1. You have a problem if you want to have the escape-character immediately before a replacement, because you don't support escaping the escape-character.
    I suggest dispensing with escape-characters, and simply replace an empty replacement {} with an opening brace {.

  2. There's no reason to modify the format-string at all, and thus receiving it by copy. Doing so is supremely inefficient. Well, using named arguments at all already is, so it might not matter too much.

  3. Do you know the ternary operator cond ? true_exp : false_exp? Using it would simplify things.

  4. Avoid allocations, thus avoid std::string. At least the format string should be C++17 std::string_view, maybe also the map should be too.
    If you template it, you don't even really have to decide for the caller:

    template <class Args = std::unordered_map<std::string_view, std::string_view>>
    std::string formatString(std::string_view format, const Args& args)
    
\$\endgroup\$
  • \$\begingroup\$ Where would the ternary operator help here, other than when checking the existence of an argument? \$\endgroup\$ – mid May 26 '18 at 18:12
  • \$\begingroup\$ Just as you said, at the end of the loop when deciding what to add. \$\endgroup\$ – Deduplicator May 26 '18 at 18:15
  • \$\begingroup\$ Some things I can't do here since I'm using C++11, but thanks! \$\endgroup\$ – mid May 26 '18 at 19:08

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.