State-Changed-From-To: open->analyzed
State-Changed-Why: Your code example is ill-formed.
    
    You defined a template function, but did not refer to
    it properly.  Your code example should be something like:
    
    template< typename ContainerAddress_ >
    void f( ContainerAddress_ p_in ) {
    }
     
    int main( const int argc, char * argv[] ) {
      int mof[argc];
     
      f<int *>( mof );
     
      return 0;
    }

From: =?iso-8859-1?Q?LEMA=CETRE?= Guillaume <guillaume.lemaitre33@wanadoo.fr>
To: rodrigc@gcc.gnu.org, guillaume.lemaitre33@wanadoo.fr
Cc:  
Subject: Re: c++/5435: Resolution of templates with thing[] types
Date: Mon, 28 Jan 2002 18:42:13 +0100

 rodrigc@gcc.gnu.org a écrit :
 > 
 > Synopsis: Resolution of templates with thing[] types
 > 
 > State-Changed-From-To: open->analyzed
 > State-Changed-By: rodrigc
 > State-Changed-When: Sun Jan 20 14:07:46 2002
 > State-Changed-Why:
 >     Your code example is ill-formed.
 > 
 >     You defined a template function, but did not refer to
 >     it properly.  Your code example should be something like:
 > 
 >     template< typename ContainerAddress_ >
 >     void f( ContainerAddress_ p_in ) {
 >     }
 > 
 >     int main( const int argc, char * argv[] ) {
 >       int mof[argc];
 > 
 >       f<int *>( mof );
 > 
 >       return 0;
 >     }
 > 
 > http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=5435
 
 I think I haven't been clear the first time
 
 I consider that mof is a container, in the sense that I can apply
 operator[] to it, as I could do if I had declared mof like this :
 
 int * mof = new int[argc];
 
 So, as the name of the typename suggests it, i want to pass the address
 of the container I have to function 'f'; so the correct call seems to be
 
 template< typename ContainerAddress_ > void f( ContainerAdress_ p_in )
 {};
 f( &mof );
 
 
 with mof declared as a variable length array or a pointer to memory;
 
 The issue is that the template cannot resolve itself to int(*)[argc].
 If I specify f< int(*)[argc] >( &mof ) it doesn't work (I get an ICP),
 that's what I wanted to point out. The fact is that I verified if taking
 address of an array was legal, it seems to be... So I don't understand
 why it doesn't compile, or g++ doesn't convert int(*)[argc] to a int**
 to call the right function 'f'
 
 Maybe I'm totally mistaking, but I don't understand why arrays doesn't
 behave the same as memory spaces dynamically allocated with operator
 new. Maybe it's not your problem, perhaps i should post that sort of
 mail to newsgroups, but I thought it was a bug, and still think it's a
 bug. Or maybe it is the way f is defined ? Should it be declared like
 this ?
 
 template< typename Container_ > void f( Container_ * p_in ) {}
 
 it doesn't work either ...
 
 friendly
 Guillaume
 
 -- 
 "C'est terrible l'intelligence. C'est le seul outil de l'homme
  qui lui permette de mesurer l'étendue de son malheur."
 
                                                   P. Desproges

From: Nathanael Nerode <neroden@twcny.rr.com>
To: gcc-gnats@gcc.gnu.org, guillaume.lemaitre33@wanadoo.fr,
   gcc-bugs@gcc.gnu.org, nobody@gcc.gnu.org
Cc:  
Subject: Re: c++/5435: ...
Date: Sat, 11 Jan 2003 18:34:27 -0500

 This only occurs with VLAs.  Note that if you replace mof[argc] with mof[5] 
 it compiles just fine.
 
 Resummarizing.

Fixed on the mainline (20030801).  Will submit a testcase.
The function is mangled as _Z1fIPiEvT_ which is void f<int*>(int*).

I was wrong the original test case does not compile still:
pr5435.cc: In function `int main(int, char**)':
pr5435.cc:8: error: no matching function for call to `f(int (*)[argc])'
2.95.3 accepted this but produced unasmeblable code.

From Phil's regression hunter: Search converges between 2001-01-14-trunk (#2) and 
2001-01-21-trunk (#3). 

The error message has changed:
pr5435.cc:8: error: no matching function for call to `f(int (*)[((long unsigned int)argc)])'

Maybe this should wait until C++ gets VLA from C99.

int (*)[argc] is not a valid template type argument, as it depends on a runtime value, and template arguments need to be known at compile time.  If you want to pass your VLA to a template function, you need to let it decay to int*.