How to call a variadic template helper in anonymous namespace?

Question

In the code below, foo should be a function accessible by anyone, but foo_helper should not, which is why I've put it in an anonymous namespace. Obviously I'm leaving out include guards and includes in this example, but they are there.

foo.h:

namespace
{
    void foo_helper() {}

    template <typename T, typename... Tail>
    void foo_helper(T head, Tail... tail)
    {
        bar(head);
        foo_helper(tail...);
    }
}

void foo();

template <typename... Args>
void foo(Args... args)
{
    before();
    foo_helper(args...);
    after();
}

foo.cpp:

void foo() {}

The problem is that in order for foo_helper's variadic template to work, it needs to have that initial version with no argument. But, this forces me to define a non-template function is a header file, which would break after including this file in multiple source files. I cannot move the definition of foo_helper to a source file because it is in an anonymous namespace, since it is not supposed to be accessible.

Is there a way to solve this issue?

BTW, you need to replace `foo_helper(args)` with `foo_helper(args...)` and `foo_helper(tail)` with `foo_helper(tail...)`. — KyleKnoepfel, Oct 15 '15 at 17:29

score 3 · Accepted Answer · edited Oct 16 '15 at 22:08

inline void foo_helper() {};

solves your problem.

inline mostly means "conflicting definitions of this function are to be discarded, and one of the versions kept".

It also non-bindingly suggests "inlining" in a vague way (in that the standard doesn't really cover what inlining is). Compilers may or may not pay attention to that suggestion.

Note that an anonymous namespace does not "make it unusable" or whatever. Anonymous namespaces are designed to block linker collisions, and that is about it. Create a namespace called details and ... well, trust users not to go and poke inside.

Using an anonymous namespace in a header is a very bad idea.

If there is an inline function (or template function) within another header file that accesses a symbol or function within the anonymous namespace, you are almost certainly going to have an ODR (one definition rule) violation. That is where the same object, function, etc has two definitions that differ, and isn't allowed to.

For example:

inline void bob() {
  foo(1,2,3);
}

if that is #included in two different .cpp files, you just made an ill-formed program (no diagnostic required).

Often such ill formed programs "behave the way you expect", but sometimes they do not. As an example, if somewhere along the line you get a static local variable whose existence depends on ODR violation, you can have multiple compilation units disagree asto which one exists and what its properties are.

In a more general sense, the link order of your program could change its behavior, as different definitions are "chosen" (with possibly extremely subtle differences). Or the phase of the moon could do the same.

ODR violations are surprisingly benign, until they byte you with non-local bugs that are hard to track down.

This does solve this specific case for me. But is there a way to make this work in general, when `inline` would be undesirable for some reason? — Leonhart231, Oct 15 '15 at 17:30
You are correct again. I'm used to embedded platforms where `inline` literally means inline. Thanks for the help! And thanks to @coppro for reminding me. — Leonhart231, Oct 15 '15 at 17:50
Using an anonymous namespace for this is a recipe for ODR violations. (And the namespace can't be called `private` ;) ) — T.C., Oct 15 '15 at 17:55
@t.c. Sure, if any `inline` function in a header file calls the function within an anonymous namespace, you are screwed (in a surprisingly benign way in practice) — Yakk - Adam Nevraumont, Oct 15 '15 at 18:35
@Leonhart231 Reasons not to use anonymous namespace added to answer. — Yakk - Adam Nevraumont, Oct 15 '15 at 18:37

score 1 · Answer 2 · answered Oct 15 '15 at 17:38

I'll start with an aside: using an anonymous namespace here doesn't serve your purpose. Since you're defining it in a header file, it's not protected at all: it will still be in scope in any file that includes your header. Additionally, since you've defined it in an anonymous namespace, a separate copy of the function will be emitted in each translation unit that uses it, and the linker can't collapse them. If you really want it to be private, I'm not on the up-and-up of the best C++ style these days, so perhaps someone else will correct me, but I would be inclined to use a private namespace:

namespace my_stuff {
    void foo_helper();
}

void foo() {
    my_stuff::foo_helper();
}

As Yakk indicated, you could use an inline function, and that will allow the compiler to collapse the definitions into one. In modern practice, there shouldn't really be another reason to avoid the inline keyword, because compilers will nowadays decide on their own whether or not to inline functions rather than listening to the hints you give.

Since you have defined the function in an anonymous namespace, as I mentioned above, you actually don't need to do anything else to avoid linker errors if you retain that. The downside to this approach is that you will have separate copies of foo_helper() in each translation unit and those can't be merged by the linker.

There are other gymnastics you could do, mostly involving sizeof..., but I don't think those are ideal.

That's a good point about the anonymous namespace. I've only used them is source files, so I didn't think that through all the way. Lots of good points here, so thank you. — Leonhart231, Oct 15 '15 at 17:47

How to call a variadic template helper in anonymous namespace?

2 Answers2