«

Gernot Frisch wrote:
> > foo(new int[]{1,2,3,4});
>
> Alrighty... Then I need to take care of deleting the pointer, though.

That sounds like a non portable extension. Fails on g++.
If you don't like the one given previously, try the following but makes
sure you make the pointer constant and do not delete, use delete[].

template< typename T >
void foo(T* const p)
{
delete [] p;
}

int main()
{
foo(new int[4]);
}

Daniel T. wrote:
> benben <benhonghatgmaildotcom@nospam> wrote:
>
> > Gernot Frisch wrote:
> > > Hi,
> > >
> > >
> > > can I somehow do something like this:
> > >
> > > void foo(int*)
> > > {}
> > >
> > > int main()
> > > {
> > > foo( {1,2,3,4} );
> > > return 0;
> > > }
> > >
> >
> > Not in the current standard. You will have to do some workarounds other
> > people have suggested. Seems to me it is very likely that C++0x will get
> > this right finally, but that's like, what, 5 more years from now?
>
> I hope C++0x won't allow the above. Passing a constant array to a
> pointer to non-const would be horrible.

If C++0x would allow it in C99's form, it would look like

void foo(int*)
{}

int main()
{
foo( (int []) {1,2,3,4} );
return 0;
}

which behaves exactly like

void foo(int*)
{}

int main()
{
int dummy[] = {1,2,3,4};
foo(dummy);
return 0;
}

There's no problem with const. You're allowed to modify the data, and
if you don't want to, you have the possibility of writing
(const int []) {1,2,3,4}.

Gernot Frisch:

> can I somehow do something like this:
>
> void foo(int*)
> {}
>
> int main()
> {
> foo( {1,2,3,4} );
> return 0;
> }


Compound literals are non-standard, but are provided by many compilers.
Here's a taste:

void Func(int const (&arr)[6]) {}

int main()
{
Foo( (int[6]){1,2,3,4,5,6} );
}

--

Frederick Gotham

Gernot Frisch wrote:

> Hi,
>
>
> can I somehow do something like this:
>
> void foo(int*)
> {}
>
> int main()
> {
> foo( {1,2,3,4} );
> return 0;
> }


Can you tell us a little bit about the limits of this problem?

Does foo have to be
void foo(int*)
or could it be
void foo(std::vector<int> &)


Does the call to foo have to be
foo( {1,2,3} );
or could it look like
foo( V().a(1).a(2).a(3).v() );

LR

Daniel T. wrote:

> I hope C++0x won't allow the above. Passing a constant array to a
> pointer to non-const would be horrible.

Well, you can do it with char* so may as well be consistant, right?

Frederick Gotham <> wrote:

>Compound literals are non-standard, but are provided by many compilers.
>Here's a taste:
>
>void Func(int const (&arr)[6]) {}
>
>int main()
>{
> Foo( (int[6]){1,2,3,4,5,6} );
>}

gcc barfs on this, as well it should.

Steve

Steve Pope:

>>Compound literals are non-standard, but are provided by many compilers.
>>Here's a taste:
>>
>>void Func(int const (&arr)[6]) {}
>>
>>int main()
>>{
>> Foo( (int[6]){1,2,3,4,5,6} );
>>}
>
> gcc barfs on this, as well it should.


Sorry, there must be some confusion -- this is comp.lang.c++, not
comp.lang.c++.my.implementation.which.has.an.exten sion.known.as.compound.lite
rals.but.which.wont.let.me.pass.an.array.compound. literal.to.a.function.which
..takes.a.reference.to.a.const.array

--

Frederick Gotham

Frederick Gotham wrote:
> Steve Pope:
>
>
>>>Compound literals are non-standard, but are provided by many compilers.
>>>Here's a taste:
>>>
>>>void Func(int const (&arr)[6]) {}
>>>
>>>int main()
>>>{
>>> Foo( (int[6]){1,2,3,4,5,6} );
>>>}
>>
>>gcc barfs on this, as well it should.
>
> Sorry, there must be some confusion -- this is comp.lang.c++, not
> comp.lang.c++.my.implementation.which.has.an.exten sion.known.as.compound.lite
> rals.but.which.wont.let.me.pass.an.array.compound. literal.to.a.function.which
> ..takes.a.reference.to.a.const.array
>
What? You said "Compound literals are non-standard" so the compiler
should barf. Or am I missing something?

--
Ian Collins.

Ian Collins:

> What? You said "Compound literals are non-standard" so the compiler
> should barf. Or am I missing something?


My lack of complaint perhaps?

--

Frederick Gotham

benben wrote:
> Gernot Frisch wrote:
> > Hi,
> >
> >
> > can I somehow do something like this:
> >
> > void foo(int*)
> > {}
> >
> > int main()
> > {
> > foo( {1,2,3,4} );
> > return 0;
> > }
> >
>
> Not in the current standard. You will have to do some workarounds other
> people have suggested. Seems to me it is very likely that C++0x will get
> this right finally, but that's like, what, 5 more years from now?
>
> You can overload operators like << and , (comma) to get something
> similar. But for many cases this seems like an overkill and as for me
> I'll just stick to
>
> int temp[] = {1,2,3,4};f
> foo(temp);
>
> Regards,
> Ben

I insist that C++ is paranoic;I cant see why one shoud be able to
write:
f("123");
but not:
f({'1','2','3','\0'});
this is painful

reguards
FM