Overloading members from template class on bool value

Question

I'm trying to avoid concepts on the master branch of my projects, so I need some kind of alternative with type_trait:

I need a class whom some few functions will change depending on the bool value.

Someone already suggest me to split my class, but this case won't make sense here. For some context it's a pool where remove function and some others will change if the object type of the pool can be shared or not.

So I tried to use std::enable_if, but there are still some errors (I want the declaration and the implementation to be separate).

#include  <type_traits>

template < typename Object, bool Shared = false >
class Foo {

  template < bool S = Shared, typename std::enable_if<S>::type* = nullptr >
  void   bar();

  template < bool S = Shared, typename std::enable_if<!S>::type* = nullptr >
  void   bar();
};

template < typename Object,
           bool Shared >
template < bool S, typename std::enable_if<S>::type* = nullptr >
void   Foo<Object, Shared>::bar() {
    //do something
}


template < typename Object,
           bool Shared >
template < bool S, typename std::enable_if<!S>::type* = nullptr >
void   Foo<Object, Shared>::bar() {
  //do nothing
}

int main() {

  Foo<int> test;
  return 0;
}

Test3.cpp:16:33: error: default argument for template parameter for class enclosing ‘void Foo<Object, Shared>::bar()’
 void   Foo<Object, Shared>::bar() {
                                 ^
Test3.cpp:24:33: error: default argument for template parameter for class enclosing ‘void Foo<Object, Shared>::bar()’
 void   Foo<Object, Shared>::bar() {

EDIT: Removed copy/paste error

songyuanyao · Accepted Answer · 2016-12-02T10:19:09.963

1.The qualification of class name (i.e. Foo<Object, Shared>::) should be deleted for member function declaration inside the class definition.

2.Default template arguments are not allowed for out-of-class definition of member templates, just remove them.

Default parameters are not allowed

in the out-of-class definition of a member template (they have to be provided in the declaration inside the class body)

Then

template < typename Object, bool Shared = false >
class Foo {

  template < bool S = Shared, typename std::enable_if<S>::type* = nullptr >
  void  bar();

  template < bool S = Shared, typename std::enable_if<!S>::type* = nullptr >
  void  bar();
};

template < typename Object,
           bool Shared >
template < bool S, typename std::enable_if<S>::type*  >
void   Foo<Object, Shared>::bar() {
    //do something
}

template < typename Object,
           bool Shared >
template < bool S, typename std::enable_if<!S>::type* >
void   Foo<Object, Shared>::bar() {
  //do nothing
}

LIVE

I found something pretty cool : https://www.youtube.com/watch?v=aXSsUqVSe2k — Mathieu Van Nevel, Dec 04 '16 at 14:33

Jarod42 · Answer 2 · 2020-09-25T14:24:30.917

As alternative, you might use tag-dispatching:

template <typename Object, bool Shared = false>
class Foo {
public:
    void bar() { bar(std::integral_constant<bool, Shared>{}); }

private:
    void bar(std::true_type);
    void bar(std::false_type);
};

template <typename Object, bool Shared>
void Foo<Object, Shared>::bar(std::true_type) { /**/ }

template <typename Object, bool Shared>
void Foo<Object, Shared>::bar(std::false_type) { /**/ }

Since C++17, you might use if constexpr:

template <typename Object, bool Shared = false>
class Foo {
public:
    void bar() {
        if constexpr (Shared) {
            // ...
        } else {
            // ...
        }
    }

So each block is only available in the right version:

so no runtime branch (I expect regular branch to be optimized anyway in your case)
not chosen block may contain code valid only when that branch would be chosen (mostly useful when it depends of type).

And C++20 introduces requires:

template <typename Object, bool Shared = false>
class Foo {
public:
    void bar() requires(Shared) {
        // ...
    }
    void bar() requires(!Shared) {
        // ...
    }
};

score 1 · Answer 3 · answered Dec 02 '16 at 10:14

Here is your code once fixed (minimal, working example):

#include  <type_traits>
#include <iostream>

template < typename Object, bool Shared = false >
class Foo {
public:
    template < bool S = Shared, typename std::enable_if<S>::type* = nullptr >
    void bar();

    template < bool S = Shared, typename std::enable_if<!S>::type* = nullptr >
    void bar();
};

template < typename Object, bool Shared >
template < bool S, typename std::enable_if<S>::type*>
void  Foo<Object, Shared>::bar() {
    std::cout << "do something" << std::endl;
}

template < typename Object, bool Shared >
template < bool S, typename std::enable_if<!S>::type*>
void Foo<Object, Shared>::bar() {
    std::cout << "do nothing" << std::endl;
}

int main() {
    Foo<int> test;
    test.bar<>();
    test.bar<true>();
    return 0;
}

It was a problem of extra qualifiers and default parameters not to be repeated in out of class definitions.

Thanks! I feel bad to have asked this now ^^ Mostly because I made an error with copy/paste for the minimal example. — Mathieu Van Nevel, Dec 02 '16 at 10:18

ABu · Answer 4 · 2016-12-02T11:22:28.930

As extra note, that is a much more cleaner solution:

#include <type_traits>
#include <iostream>

template<bool b>
using allow_if = typename std::enable_if<b>::type;

template <typename Object, bool Shared = false>
class Foo {
public:
    template<bool S = Shared>
    allow_if<S> bar();

    template<bool S = Shared>
    allow_if<!S> bar();
};

template<typename Object, bool Shared>
template<bool S>
allow_if<S> Foo<Object, Shared>::bar() {
    std::cout << "do something" << std::endl;
}

template<typename Object, bool Shared>
template<bool S>
allow_if<!S> Foo<Object, Shared>::bar() {
    std::cout << "do nothing" << std::endl;
}

int main() {
    Foo<int> test;
    test.bar<>();
    test.bar<true>();
    return 0;
}

Overloading members from template class on bool value

4 Answers4