CODEWITHSUNDEEP
c++classnamespacestypedefprivate
user2138149
user2138149

Reputation: 17314

Private Class within Namespace

I have a class within a namespace in a header file. The class requires a template type, and I only want certain types to be used. Below shows an example.

File a.hpp

// a.hpp
namespace a_ns {
template<class T>    
class a {
    // stuff
};
typedef a<double> a_double;
} // end of namespace
// stuff

File b.hpp

// b.hpp
#include <a.hpp>
namespace b_ns {
    typedef a_ns::a_double b;
}

File main.cpp

// main.cpp
#include "b.hpp"
int main() {
    b_ns::b my_b; // <<<--- I LIKE this!
    a_ns::a<float> my_a_which_is_not_allowed; // <<<--- I DO NOT LIKE THIS THOUGH! D:
}

So as you can see from the rather longed out example, the end objective is to NOT ALLOW the end user to declare a class a with float as the typename, and to only be able to use the pre-defined classes with specific types, as declared by typedef a<double> a_double;.

I thought this example above would allow this, however I was wrong, as I can create an a<float> as above, because I include b.hpp, which in turn includes a.hpp! So you see the problem! (hopefully?)

There is probably a simple solution, if this is at all possible.

Upvotes: 6

Views: 2380

Answers (2)

Qaz
Qaz

Reputation: 61970

If you only want to be able to use the type aliases and not use a directly, you can put it into an implementation namespace that users should know not to use:

namespace a_ns {

namespace detail {
    template<class T>        
    class a {
        // stuff
    };
}

typedef detail::a<double> a_double;
} // end of namespace

Now anything can use a_double, but to use a directly, your detail namespace would have to be dug into, and that's generally accepted as a bad thing to do. If a user decides they want to do that, they've already given up on staying out of trouble and you shouldn't take extra measures to stop them from hurting themself.

Upvotes: 6

aaronman
aaronman

Reputation: 18751

Here's how you can use a static_assert

#include <type_traits>
template <typename T>
class X
{
  T i;
  static_assert(!std::is_same<float,T>::value,"Don't use floating point");
};



int main()
{
    X<int> a;
    //X<float> b; fails at compile time
    return 0;
}

This will work as long as the variable is not const or volatile

Upvotes: 0

Related Questions