这个函数很棒：

template<typename T, std::size_t N>
constexpr T* temporary_array(T(&& arr)[N]) noexcept { return arr; }

然后，您可以简单地调用f(temporary_array<double>({1,2}));（或f(temporary_array({1., 2.}))）。
在C20中，你可以写f(std::type_identity_t<double(&&)[]>{1,2})。f(std::type_identity_t<double[]>{1, 2})也应该在任何C版本中工作，但GCC有一个长期存在的错误，不允许编译。
寻找标准库解决方案，您的struct A可以替换为std::array<double, 2>。写出size参数很烦人，但可以用CTAD代替：

f(std::array{ 1., 2. }.data());
f(std::array<double, 2>{1, 2}.data());
// (These will call move constructors)
f(std::to_array<double>({1, 2}).data());
f(std::to_array({1., 2.}).data());

用vector代替double*怎么样？然后你可以在调用站点构建一个in-place，如下所示：

#include<vector>

double f(std::vector<double> const& v)
{
  return v[0];
}

int main()
{
  f({1,2,3});
}

如果你能用c++20编译，那么最明显的答案是使用std：：span，以获得最大的灵活性。
Demo:

#include <array>
#include <span>
#include <vector>

void f(std::span<const double> a);

int main()
{
    f({{1.0, 2.0, 3.3}});

    double ca[] = { 1.2, 3.4 };
    f(ca);

    std::vector<double> v = { 1.2, 3.4 };
    f(v);

    std::array a = { 1.2, 3.4 };
    f(a);
}

如果要避免动态分配，请使用std::initializer_list

template <typename T>
void f(const std::initializer_list<T>& v)
{
    for (const auto& e : v)
        std::cout << e << " ";
    std::cout << "\n";
}

int main()
{
    f({1,2,3});
    f({4.0,5.1,6.2});
}

产出
Live example

你的函数签名是错误的。它可以被修复和改进。参见：https://godbolt.org/z/WoME5xazr

#include <iostream>

void foo(double (&arr)[])
{
    std::cout<<arr[0]<<std::endl;
}
template<size_t N>
void BetterFoo(double (&arr)[N])
{
    for (size_t i = 0;i<N;++i)
    {
        std::cout<<arr[i]<<std::endl;
    }
}

int main()
{
    double a[] = { 1.2, 3.4 };
    foo(a);
    std::cout<<"better foo"<<std::endl;
    BetterFoo(a);
    return 0;
};

希望能帮上忙