passing unnamed array to function

[poorboywilly]

I've been unable to find any information on this through any search
engines. Is there any way to pass an unnamed (temporary) array to a
function?
e.g.

void f0(const int ar[5]);
void f1(const int ar[]);
f0( {1, 2, 3, 4, 5} ); //does not compile
f1( {1, 2, 3} ); //does not compile

int n_set[] = {1, 2, 3, 4, 5};
f0(n_set); //these both compile (of course)
f1(n_set);

I know I can use an STL container instead and pass an unnamed STL
container, but an STL container doesn't allow me to set construct it
with, say, 5 arbitrary values.

So I guess my question is, why can I not initialize a function
argument with the array "shorthand" notation, and is there an
alternative syntax that will allow this?

thanks,
--Jason

[Victor Bazarov]

poorboywilly wrote:

I've been unable to find any information on this through any search
engines. Is there any way to pass an unnamed (temporary) array to a
function?

There are no "array literals" in C++ (beyond arrays of 'char const').

You can probably create a way. Here is what you need to do. Define
a class (better a template) which will have a constructor with '...'
for the argument. It will manage its own memory, say. A member of
that class will be the pointer to the dynamic memory, so you would
be able to use syntax like

f1(make_array(1,2,3,4).pointer);

It might look something like

template<class Tstruct make_array_t {
T *pointer;
make_array_t(T t ...); // the constructor - allocates and
// fills the memory
~make_array_t();
private:
// those are prohibited
make_array_t& operator=(make_array_t const&);
make_array_t(make_array_t const&);
};

// and here is the factory:
template<class Tmake_array_t<Tmake_array(T t ...);

All you need to figure out is how you manage the variadic arguments
(how you stop processing the list, that is).

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Puppet_Sock]

On Jan 3, 2:08*pm, poorboywilly <[e-mail]:

I've been unable to find any information on this through any search
engines. *Is there any way to pass an unnamed (temporary) array to a
function?
e.g.

void f0(const int ar[5]);
void f1(const int ar[]);

f0( {1, 2, 3, 4, 5} ); * * //does not compile
f1( {1, 2, 3} ); * * * * * *//does not compile

[snip]

What are you trying to accomplish through this?
Possibly there's a better way to get it than by
doing this.

int n_set[] = {1, 2, 3, 4, 5};
f0(n_set); //these both compile (of course)
f1(n_set);

If you just put that in a scope, say with { }
around it, would that accomplish what you want?
Or by putting this stuff inside a function call.
Socks

[Joe Greer]

poorboywilly <j.*****@aggiemail.usu.eduwrote in news:5b04358b-3510-
43********************@h11g2000prf.googlegroups.co m:

I've been unable to find any information on this through any search
engines. Is there any way to pass an unnamed (temporary) array to a
function?
e.g.

void f0(const int ar[5]);
void f1(const int ar[]);
f0( {1, 2, 3, 4, 5} ); //does not compile
f1( {1, 2, 3} ); //does not compile

int n_set[] = {1, 2, 3, 4, 5};
f0(n_set); //these both compile (of course)
f1(n_set);

I know I can use an STL container instead and pass an unnamed STL
container, but an STL container doesn't allow me to set construct it
with, say, 5 arbitrary values.

So I guess my question is, why can I not initialize a function
argument with the array "shorthand" notation, and is there an
alternative syntax that will allow this?

The short answer is because the C++ syntax doesn't allow it. The longer
answer is that in general, objects have to exist somewhere. In the case
of temporary objects, this is normally on the stack, though compilers
are allowed to put them anywhere. Thing is, after the temporary goes
out of scope, the memory is reclaimed. This doesn't leave a lot of
options for temporary arrays. Most of the languages which allow what
you wrote also have garbage collectors tightly integrated with the
language. This more easily allows temporaries to be put in the garbage
collected heap, because you don't have to worry about leaking the
allocated memory. This kind of tight integration with a garbage
collector will never be the case in C++.

You could look at the 'assign' library in boost. It lets you write
things like.

std::vector<intv;
v += 1,2,3,4,5;

And a few other collection initializing tricks.

HTH,
joe

[Joe Greer]

Joe Greer <jg****@doubletake.comwrote in news:Xns9A1A976967FAFjgreerdoubletakecom@
194.177.96.78:

>
You could look at the 'assign' library in boost. It lets you write
things like.

std::vector<intv;
v += 1,2,3,4,5;

And a few other collection initializing tricks.

Actually, the boost assign library has a to_list() routine which allows for the
construction of temporary arrays (at least in some contexts).

joe

[poorboywilly]

On Jan 3, 12:53 pm, Joe Greer <[e-mail]:

>
The short answer is because the C++ syntax doesn't allow it. The longer
answer is that in general, objects have to exist somewhere. In the case
of temporary objects, this is normally on the stack, though compilers
are allowed to put them anywhere. Thing is, after the temporary goes
out of scope, the memory is reclaimed. This doesn't leave a lot of
options for temporary arrays. Most of the languages which allow what
you wrote also have garbage collectors tightly integrated with the
language. This more easily allows temporaries to be put in the garbage
collected heap, because you don't have to worry about leaking the
allocated memory. This kind of tight integration with a garbage
collector will never be the case in C++.

I don't quite see it...the compiler knows at compile time how big this
array is going to be, and that it will last the length of the function
call. It knows how much space to reserve on the stack and then how
much to take off when it is done.

--Jason

[Ian Collins]

poorboywilly wrote:

On Jan 3, 12:53 pm, Joe Greer <[e-mail]:

>The short answer is because the C++ syntax doesn't allow it. The longer
answer is that in general, objects have to exist somewhere. In the case
of temporary objects, this is normally on the stack, though compilers
are allowed to put them anywhere. Thing is, after the temporary goes
out of scope, the memory is reclaimed. This doesn't leave a lot of
options for temporary arrays. Most of the languages which allow what
you wrote also have garbage collectors tightly integrated with the
language. This more easily allows temporaries to be put in the garbage
collected heap, because you don't have to worry about leaking the
allocated memory. This kind of tight integration with a garbage
collector will never be the case in C++.

I don't quite see it...the compiler knows at compile time how big this
array is going to be, and that it will last the length of the function
call. It knows how much space to reserve on the stack and then how
much to take off when it is done.

Everything after the first sentence above is a bit of a red herring, the
most concise explanation was from Victor - 'There are no "array
literals" in C++ (beyond arrays of 'char const').'

--
Ian Collins.