can we pass arrays as arguments to functions by this syntax, under upcoming c++0x standards ?

Question

suppose we have following function:

void someFunction(int * araye){
 for (int i=0;i<5;i++)
  cout <<araye[i]<<' ';
 cout <<'\n';
}

can we pass an array to this function by following syntax, under upcoming c++0x standards? :

someFunction({1,2,3,4,5});

if that's true, will we even be able to use this syntax in any case in which, array elements are from POD types like below :

class Test{
 int adad1;
 int adad2;
};
void someFunction(Test * araye){
 for (int i=0;i<3;i++)
  cout <<araye[i].adad1<<'-'<<araye[i].adad2<<' ';
 cout <<'\n';
}
someFunction({{1,2},{3,4},{5,6}});

Edit->after what people said:
So you guys are telling that the expression between braces will be basically treated as an initializer_list and are proposing using an extra function that pulls a pointer out of that initializer_list and passes it to the intended function, but this method seems to me like a hack to be able to use my intended function with that expression as an argument, with that said I think I shouldn't use that expression as an argument at all, when my intended function parameter is a single pointer, or there might be another approach to use that expression? .

Answer 1

Wikipedia would seem to suggest that you can do this but only by declaring the function to take a std::initializer_list<int> as an argument.

Answer 2

The type of the expression {1,2,3,4,5} is std::initializer_list<int>. It's an object which has member functions size(), begin(), end(), but no operator[] (per 18.9/1 of the C++0x FCD)

If your function took std::vector or any other standard container, this would work because containers can be constructed from initializer_lists (they all provide non-explicit constructors that take them):

void someFunction(std::vector<int> araye)
{
         for (int i=0;i<5;i++)
                   std::cout << araye[i] <<' ';
         std::cout <<'\n';
}
int main()
{
        someFunction({1,2,3,4,5});
}

If you want to have a function that takes a pointer, you will need to somehow manually convert an initializer_list into something that you can access in such manner:

void someFunction(int* araye)
{
         for (int i=0;i<5;i++)
                   std::cout << araye[i] <<' ';
         std::cout <<'\n';
}
void someFunction(std::vector<int> v)
{
        someFunction(&v[0]);
}
int main()
{
        someFunction({1,2,3,4,5});
}

Answer 3

If your function takes const int*, rather than int*, then you just need a small trampoline function to pull the pointer out of the std::initializer_list<int> that the brace initialiser produces. Something like this (probably; I don't have a C++0x compiler to test with)

void someFunction(const int * array){
    for (int i=0; i<5; i++)
        std::cout << array[i] << ' ';
    std::cout << '\n';
}

void someFunction(const std::initializer_list<int>& init) {
    someFunction(init.begin());
}

someFunction({1,2,3,4,5});

If your function needs to know the end or size of the array (which will usually be the case), then pass either init.end() or init.size() as a second argument.