Ukrywanie szablonowej funkcji helpera - statyczne elementy lub nienazwana przestrzeń nazw

Question

Próbuję napisać bibliotekę, w której mam pewne szablony funkcji, z których niektóre są funkcjami pomocniczymi, więc nie chcę, aby moi użytkownicy mieli do nich dostęp. Podstawowym kodem może być

//mylib.h 

namespace myfuncs 
{ 
    template<class T> 
    void helper (T input, int extrainformation) 
    { 
     //do some usefull things 
    } 

    template<class T> 
    void dostuff(T input) 
    { 
     int someinfo=4; 
     helper(input, someinfo); 
    } 
} 

Czy jest możliwe, aby jakoś ukryć funkcję pomocnika, aby użytkownicy biblioteki nie mogli jej wywołać bezpośrednio? Myślałem, że nienazwana przestrzeń nazw może wykonać to zadanie, ale ponieważ używam szablonów, nie mogę podzielić deklaracji funkcji i treści między nagłówek i plik implementacji. Umieszczenie nienazwanego obszaru nazw w pliku nagłówkowym jest bezużyteczne i ma zły styl. Jedyne, co mogę zrobić, to stworzyć klasę mylib i hermetyzować funkcje jako prywatne/publiczne funkcje statyczne.

Wszelkie lepsze rozwiązania byłyby mile widziane.

Phil

Answer 1

Jednym ze sposobów, aby to zrobić jest mieć "szczegół" lub nazw "wewnętrzne". To, ile bibliotek to robi.

namespace myfuncs 
{ 
    namespace detail 
    { 
     template<class T> 
     void helper (T input, int extrainformation) 
     { 
      //do some usefull things 
     } 
    } 

    template<class T> 
    void dostuff(T input) 
    { 
     int someinfo=4; 
     detail::helper(input, someinfo); 
    } 
} 

Answer 2

Czy to, co wiele bibliotek szablonów (jak Eigen) zrobić: użyj wyraźnie nazwie nazw implementacji specyficznych (np myfuncs::impl) i opierają się na hermetyzacji społecznej (tj użytkownik nie skłonny zadzwonić szablony z wdrożenia przestrzeń nazw).

Answer 3

Można:
W header.h:

#ifndef AAA_H 
#define AAA_H 
namespace myfuncs 
{ 
    template<class T> 
    std::string dostuff(); 
} 
#include "aaa.cpp" 
#endif // AAA_H 

W source.cpp:

#define AAA_CPP 
#include <string> 
namespace { 
    template<class T> 
    std::string helper() 
    { 
    return "asdf"; 
    } 
} 

namespace myfuncs 
{ 
    template<class T> 
    std::string dostuff() 
    { 
     return helper<T>(); 
    } 
} 
#endif // AAA_CPP 

W main.cpp:

#include <iostream> 
#include "aaa.h" 

int main(int argc, char *argv[]) 
{ 
    std::cout << myfuncs::dostuff<std::string>(); 
    return 0; 
}