Take five seconds to think about it before reading on.

I suspect the first thing that comes to mind for you is the same thing that came to mind for me — call typeid(T) inside the function to check the type of T, and branch on it:

if (typeid(T) == typeid(std::string)) {
	// default behavior for string
}

Sorry, but no. It doesn't work, and things are nowhere near as simple as we'd like.

So what happens? Let's look at a complete example first.

#include <string>
#include <vector>
#include <iostream>

template<typename T>
class Printer
{
public:
    Printer() { }

    void DoIt(const T& t)
    {
        if (typeid(T) == typeid(std::string)) {
            std::cout << t << std::endl;
        } else {
            std::cout << "I don't know how to print" << std::endl;
        }
    }
};

int main(int argc, char** argv)
{
    Printer<std::string> p;
    p.DoIt("WTF");

    Printer<std::vector<char>> p2;
    p2.DoIt({'W', 'T', 'F'});

    return 0;
}

Compile it:

% clang++ SFINAE.cpp -std=c++11
SFINAE.cpp:14:23: error: invalid operands to binary expression ('ostream' (aka 'basic_ostream<char>') and 'const std::vector<char, std::allocator<char> >')
            std::cout << t << std::endl;
            ~~~~~~~~~ ^  ~

The compiler tells us it can't call std::cout << t << std::endl — t is a std::vector<char>.

By now you can probably see it: on line 14 of the example above, the compiler instantiated the template with std::vector<char>, and the instantiated Printer looks like this:

class Printer
{
public:
    Printer() { }

    void DoIt(const std::vector<char>& t)
    {
        if (typeid(std::vector<char>) == typeid(std::string)) {
            std::cout << t << std::endl;
        } else {
            std::cout << "I don't know how to print" << std::endl;
        }
    }
};

The if on line 8 can never be true, but the compiler isn't that clever. All it sees is that you're trying to stream a std::vector<char> into std::cout, and that of course doesn't work.

You might be thinking: if the compiler were smart enough to eliminate a branch that can never execute at compile time, wouldn't that solve it? Let's set that aside for now, and look at how to solve this under C++11 instead. In other words: how do we implement a "compile-time if"?

Another idea comes to mind —

how do we get something like "partial specialization" for a class member function?

Here's the correct answer up front. Don't close the tab yet; I'll walk through it.

class Printer
{
public:
    Printer() {
    }

    template <typename U = T>
    void
    DoIt(const T& t, typename std::enable_if<std::is_same<U, std::string>::value, void>::type * = nullptr)
    {
        std::cout << t << std::endl;
    }

    template <typename U = T>
    void
    DoIt(const T& t, typename std::enable_if<!std::is_same<U, std::string>::value, void>::type * = nullptr)
    {
        std::cout << "I don't know how to print" << std::endl;
    }
};

Let's start with the title of this post. SFINAE stands for "Substitution failure is not an error".

typename

http://feihu.me/blog/2014/the-origin-and-usage-of-typename/

SFINAE

https://zhuanlan.zhihu.com/p/21314708

immediate context

https://codeday.me/en/qa/20190306/13897.html

std::enable_if_

A year after buying this domain to blog on, without having written a single post, namesilo came asking me to renew. Paying that $7.99 stung a little — I'd sat on it for a year and done nothing with it.

2. The Curse

Setting aside my questionable writing, there were a few moments this past year when I actually felt the urge to write something. I even started a couple of times, but every one of them died on the vine. Looking back at why: at some point I started caring more about how much productivity my tools could give me than about actually producing anything. Tools that don't fit your hand make production cost more mental energy, and that makes you not want to produce at all. This chart from Reddit's vim board captures the state perfectly:

There are upsides and downsides to living like this. Take blogging:

Cons: every one of those urges this year got dropped because I didn't have a tool I was happy with. This time, after the renewal stung, I finally found one I like — Ulysses — and that's the only reason I could write this filler piece in the middle of a busy schedule (I wasn't busy; the filler part is true). Though inserting images is still not a smooth experience (

Pros: this tool also made me realize that collecting notes and organizing notes don't have to happen in the same app. So I'm dropping the extremely buggy Wiz Note I've been using and switching to Ulysses + Evernote. Here's hoping for a great leap forward in productivity (wait, that doesn't sound right

3. The Productivity

Section 2 was originally titled Curse of Productivity. Worried I'd misspelled something, I googled it — and found Observer's article The Curse of Productivity, which describes roughly the same state I was in. So I just renamed the whole post to match. It cites the Pareto principle: 20% of the time gets you 80% of the productivity gain, and the remaining 20% of the gain costs the other 80% of the time — to the point where the time you save from being more productive may not even cover the time you spent getting there. I feel this in my bones. 80% of the time I've spent configuring vim went toward chasing that last 20%.

The article also argues that being too efficient makes you less creative. I don't buy that one. If higher productivity lowers the mental energy a task demands, then you have more mental energy left over for the creative things.

4. The End

This went downhill from the title, but that's enough rambling. Here's hoping I actually produce more this year — Consume less, create more!

Look at this post — still writing about productivity!