arrays as parameters in c++ without creating variable

As of C++11, you can use std::initializer_list< >:

#include <iostream>
#include <initializer_list>

int sum( std::initializer_list< int > a ){
  int c = 0;

  for( int value : a ) {
    c += value;
  }

  return c;
}

int main( ) {
  std::cout << sum( { 1, 2, 3, 4, 5 } ) << '\n';
    
  return 0;
}

Note that you can't use the indirection operator this way []: you have to iterate through your list of numbers using iterators; Which, in conjunction with range-based-for , really makes the code a lot easier to write and read.

Note also that both usages are not equivalent . If the function expects a pointer, you can't pass it a initializer_list. And vice versa. Although this is simple to fix using function overloading:

#include <iostream>
#include <initializer_list>

int sum( std::initializer_list< int > a ){
  int c = 0;

  for( int value : a ) {
    c += value;
  }

  return c;
}

int sum( int *ptr, size_t count ) {
  int c = 0;

  for( int idx = 0; idx < count; ++idx ) {
    c += ptr[idx];
  }

  return c;
}

int main( ) {
  std::cout << sum( { 1, 2, 3, 4, 5 } ) << '\n';

  int arr[] = { 1, 2, 3, 4, 5, 6 };

  std::cout << sum( arr, sizeof( arr ) / sizeof( arr[0] ) ) << '\n';
    
  return 0;
}

What I want to know is if I can call the array by value and not by reference, that is, change sum(a, b)by sum({1,2,3,4,5}, b)without having to create the variable.

No, You can not. Arrays cannot be passed by value since they decay to a pointer as a parameter, we can see it in this example:

void pasa_arreglo(int arreglo[5])
{
    std::cout << __PRETTY_FUNCTION__ << '\n';
}

int main()
{
    int a[] = {1, 2, 3, 4, 5};

    pasa_arreglo(a);

    return 0;
}

The code above shows:

void pasa_arreglo(int *)

So if we try to create and call the function sumpassing an array by value:

int sum(int a[5], int b)
{
    int c{};
    for (int i = 0; i != b; ++i)
        c += a[i];
    return c;
}

int main()
{
    std::cout << sum({1, 2, 3, 4, 5}, 5) << '\n'
    return 0;
}

We get the following error:

error: no matching function for call to 'sum'
<< sum({6, 7, 8, 9, 0}, 5);
   ^~~
note: candidate function not viable: cannot convert initializer list argument to 'int *'
int sum(int a[5], int b)
    ^

The array passed by value decays to a pointer and you cannot use an initialization list to initialize a pointer. But, contrary to what you think , passing the array as a constant reference solves the problem:

int sum(const int (&a)[5])
{
    int c{};
    for (const auto &v : a)
        c += v;
    return c;
}

int main()
{
    std::cout << sum({1, 2, 3, 4, 5}) << '\n'
    return 0;
}

You can see the code working in Try it online!. If you want no limit on the number of elements, use a template:

template <unsigned S>
int sum(const int (&a)[S])
{
    int c{};
    for (const auto &v : a)
        c += v;
    return c;
}

One way to solve your doubt is using functions with variable arguments:

You need to include the header cstdarg. You can use all the known parameters, and at the end put the ellipses ..., which will be replaced by the unknown ones.

One limitation is that you have to indicate the number of parameters that are going to go. This can be done by using one of the parameters as information, or by putting a value at the end indicating that it no longer has to consider any more parameters. There also has to be a "normal" parameter, you can't just put the ellipses.

I put both versions. In sumarAthe known parameter it is the first addend, and it is put nullptrto indicate that it is no longer necessary to continue. In the second version sumarB, the known parameter indicates the number of addends, and will be used to iterate over the unknown parameters.

You need to include the macros va_list, va_startandva_end

#include <iostream>
#include <cstdarg>
using namespace std;

int sumarA(int a, ...);
int sumarB(int elementos, ...);

int main()
{
    cout<<sumarA(1, 2, nullptr)<<endl;
    cout<<sumarA(3, 4, 5, nullptr)<<endl;
    cout<<sumarB(2, 3, 4)<<endl;
    cout<<sumarB(3, 1, 5, 8)<<endl;

    return 0;
}

int sumarA(int a, ...)
{
    va_list p;
    va_start(p, a);
    int arg;
    int suma = a;

    while ((arg = va_arg(p, int)))
    {
        suma+=arg;
    }
    va_end(p);
    return suma;
}

int sumarB(int elementos,...)
{
    va_list p;
    va_start(p, elementos);
    int suma = 0;
    for (int i=0;i<elementos;i++)
    {
        suma+=va_arg(p, int);
    }
    va_end(p);
    return suma;
}

http://c.conclase.net/curso/?cap=020b#PAR_VARIABLES

either

http://www.cplusplus.com/reference/cstdarg/va_arg/