C++ Template argument changes Reference to Pointer

Question

Maybe I didn't know how to search, but it's fact that I couldn't find anyone talking about this.

I have struct that has a non-type argument that depends on a type argument.

template<
    typename SpecType,
    SpecType NonType >
struct Struct
//...

When SpecType is a reference to a pointer (const char *&, for example) NonType behaves as if it is the address of the actual specialized argument, and not a reference. More surprising is that if I explicitly cast NonType to SpecType, everything works as expected!

IBM says something about conversion to pointer of arrays and functions, but I don't understand it as related to my doubt.

When I create structs that have no embedded template types (S1 and S2) the same thing does ot happen.

Of course I can change it to:

template<
    typename SpecType,
    SpecType &NonType >

but it won't explain what I see. Can anyone please give a deep (or dumb, if it is my stupidness) explanation?

---

The following example is a bit extense, but looking at its output I think my problem will be more clear:

#include    <iostream>
#include    <typeinfo>

using namespace std;


void    f1( const char **p )
{
    cout << "---------------------------------------------" << endl;
    cout << "f1( const char **p ): p = \"" << p << "\"" << endl;
}

void    f1( const char *p )
{
    cout << "---------------------------------------------" << endl;
    cout << "f1( const char *p ): p = \"" << p << "\"" << endl;
}

void    f1( const int **p )
{
    cout << "---------------------------------------------" << endl;
    cout << "f1( const int **p ): p = \"" << p << "\"" << endl;
}

void    f1( const int *p )
{
    cout << "---------------------------------------------" << endl;
    cout << "f1( const int *p ): p = \"" << p << "\"" << endl;
}

template<
    typename SpecType,
    SpecType NonType >
struct Struct
{
    void    f( )
    {
        cout << "---------------------------------------------" << endl;
        cout << "SpecType is " << typeid( SpecType ).name( ) << endl;
        cout << "NonType is " << typeid( NonType ).name( ) << endl;
        cout << "NonType = \"" << NonType << "\"" << endl;
        cout << "( SpecType )NonType = \"" << ( SpecType )NonType << "\"" << endl;
        cout << "*NonType = \"" << *NonType << "\"" << endl;
        cout << "*NonType[ 0 ] = \"" << **NonType << "\"" << endl;

        f1( NonType );
    }
};

template< const char *&P >
struct  S1
{
    void    f( )
    {
        cout << "---------------------------------------------" << endl;
        cout << "&P = \"" << &P << "\"" << endl;
        cout << "P = \"" << P << "\"" << endl;
        cout << "*P = \"" << *P << "\"" << endl;

        f1( P );
    }
};

template< const char **P >
struct  S2
{
    void    f( )
    {
        cout << "---------------------------------------------" << endl;
        cout << "P = \"" << P << "\"" << endl;
        cout << "*P = \"" << *P << "\"" << endl;
        cout << "*P[ 0 ] = \"" << **P << "\"" << endl;

        f1( P );
    }
};

const char * const_pname    = "name";

const int   pint[]  = { 42, 51 };
const int   *const_pint = pint;

int main( )
{
    cout << "=============================================" << endl;
    cout << "const_pname = " << const_pname << endl;
    cout << "@const_pname = 0x" << hex << ( unsigned long )const_pname << dec << endl;
    cout << "&const_pname = 0x" << hex << ( unsigned long )&const_pname << dec << endl;

    cout << "=============================================" << endl;
    cout << "Struct< const char *&, const_pname >   constpTtname" << endl;
    Struct< const char *&, const_pname >    constpTtname;
    constpTtname.f( );

    cout << "=============================================" << endl;
    cout << "Struct< const int *&, const_pint > constpTtint" << endl;
    Struct< const int *&, const_pint >  constpTtint;
    constpTtint.f( );

    cout << "=============================================" << endl;
    cout << "S1< const_pname >  s1" << endl;
    S1< const_pname >   s1;
    s1.f( );

    cout << "=============================================" << endl;
    cout << "S2< &const_pname > s2" << endl;
    S2< &const_pname >  s2;
    s2.f( );

    return  0;
}

The output is:

$ ./nontype_mutant
=============================================
const_pname = name
@const_pname = x401624                                                                   
&const_pname = 0x601e18                                                                   
=============================================                                             
Struct< const char *&, const_pname >    constpTtname                                      
---------------------------------------------                                             
SpecType is PKc                                                                           
NonType is PKc                                                                            
NonType = "$@"                                                                            
( SpecType )NonType = "name"                                                              
*NonType = "name"                                                                         
*NonType[ 0 ] = "n"                                                                       
---------------------------------------------                                             
f1( const char *p ): p = "$@"                                                             
=============================================                                             
Struct< const int *&, const_pint >      constpTtint                                       
---------------------------------------------                                             
SpecType is PKi                                                                           
NonType is PKi                                                                            
NonType = "0x601e20"                                                                      
( SpecType )NonType = "0x4017a8"                                                          
*NonType = "0x4017a8"                                                                     
*NonType[ 0 ] = "42"                                                                      
---------------------------------------------                                             
f1( const int *p ): p = "0x601e20"                                                        
=============================================                                             
S1< const_pname >       s1
---------------------------------------------
&P = "0x601e18"
P = "name"
*P = "n"
---------------------------------------------
f1( const char *p ): p = "name"
=============================================
S2< &const_pname >      s2
---------------------------------------------
P = "0x601e18"
*P = "name"
*P[ 0 ] = "n"
---------------------------------------------
f1( const char **p ): p = "0x601e18"

Answer 1

I've tried to compile your code using three compilers and two of them have very similar behavior giving the following message (approximately):

test.cpp:44:41: error: indirection requires pointer operand ('int' invalid)
        cout << "*NonType[ 0 ] = \"" << **NonType << "\"" << endl;
                                        ^~~~~~~~~
test.cpp:93:18: note: in instantiation of member function 'Struct<const char *&, const_pname>::f' requested here
    constpTtname.f( );
                 ^
test.cpp:44:41: error: indirection requires pointer operand ('int' invalid)
        cout << "*NonType[ 0 ] = \"" << **NonType << "\"" << endl;
                                        ^~~~~~~~~
test.cpp:98:17: note: in instantiation of member function 'Struct<const int *&, const_pint>::f' requested here
    constpTtint.f( );
                ^
2 errors generated.

The error message seems correct and self evident to me. This was the result of using clang. Comeau's EDG based compiler was the other one to give a message very similar to this.

g++ compiled it (I believe incorrectly) and gave an output similar to that you report.