Single method string formatter 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&lt;iostream&gt;
#include&lt;unordered_map&gt;
#include&lt;string&gt;

using std::string;
string formatString(string format, const std::unordered_map&lt;string, string&gt;&amp; args) {
    string ret;

    string::size_type bracketLoc;
    while((bracketLoc = format.find_first_of('{')) != string::npos) {
        // Handling the escape character.
        if(bracketLoc &gt; 0 &amp;&amp; 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-&gt;second;
        }
    }

    ret += format;

    return ret;
}

int main() {
    std::cout &lt;&lt; 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?.
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 {.
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.
Do you know the ternary operator cond ? true_exp : false_exp? Using it would simplify things.
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 &lt;class Args = std::unordered_map&lt;std::string_view, std::string_view&gt;&gt;
std::string formatString(std::string_view format, const Args&amp; args)