[boost] Re: Template argument deduction question

From: Vladimir Prus (ghost_at_[hidden])
Date: 2005-06-03 06:48:28

David Abrahams wrote:

>> Below is the test program:
>>
>>     
>>     char* cmdline3_[1] = {};
>>     
>>     template<class charT>
>>     void func(const charT* const argv[]) {}
>>     
>>     int main()
>>     {
>>         // P is 'const charT* const argv[]'cmdline3_
>>         // A is 'char* cmdline3_[]'
> 
> I think A is   'char*[1]'

Yes, but it still should be converted to char** for template argument
deduction.

>>         // According to 14.8.2.1/2
>>         // If P is not reference type
>>         //    -If A is an array type, the pointer type produced
>>         //     by the array-to-pointer standard convertion (4.2)
>>         //     is used in place of A for type deduction.
>>         //
>>         // So, A should become 'char**'
>>
>>         // The following does not compile.
>>         func(cmdline3_);
>>     
>>         char** p = cmdline3_;
>>         // This does compile, even though the argument type used for
>>         // type deduction should be the same as in example above.
>>         func(p);
>>     
>>     }
>>  
>> Anybody can explain what's going on?
> 
> It's well known that converting a char** into a char const** is a
> type-safety hole, so the language doesn't allow it (see D&E for the
> details, I think).  

I know that. What's why the function argument is not (const charT* argv[])
but (const charT* const argv[])

> 'char*[1]' converts (by array-to-pointer) to 'char**', 
> but a 'const charT* const[]' parameter is equivalent to char const*
> const*', so a similar logic applies.

I don't think so. In the second call, passing "char**" to the same function
works without any problems. It looks like in the first call, compiler
"forgets" to promote array to pointer.

- Volodya