很不幸你的要求是不可能的。
这种情况下的根本问题是const只在顶层传播。
因此，使指针为const只会使指针本身为const，而不会使指向的对象为const。
这对于任何包含指针的类都是正确的，而不仅仅是std::array：godbolt

std::array<int*, 2> arr = { &a, &b };
auto const& arrref = arr;
static_assert(std::same_as<decltype(arrref[0]), int* const&>); // not int const * const&!

struct Foo {
    int* ptr;
    auto& get() const { return ptr; }
};
Foo foo{&a};
auto const& fooref = foo;
static_assert(std::same_as<decltype(fooref.get()), int* const&>); // not int const * const&!

你需要一个指针类型来将它的常量传播给被指向的类型。
std::propagate_const（不幸的是，作为库基础TS的一部分，它仍然是实验性的）就是这样做的：它 Package 了一个类似指针的类型，以便将const传播到指向的对象。
示例：godbolt

using std::experimental::propagate_const;

void test(std::array<propagate_const<int*>, 2> const& arr)
{
    // ill-formed:
    //*arr[0] = 20;
}

int main()
{
    int a = 5;
    int b = 10;
    std::array<propagate_const<int*>, 2> arr = {&a, &b};
    test(arr);

    // well-formed
    *arr[0] = 42;

    return 0;
}

另一个适用于C++20的选项是使用std::span。
std::span本质上只是一个指向数组的指针，因此您可以根据需要向元素类型添加尽可能多的const（就像在您的c-array示例中一样，您将数组衰减为指针以添加常量）
示例：godbolt

void test(std::span<int const* const> arr)
{
    // ill-formed:
    //*arr[0] = 20;
}

int main()
{
    int a = 5;
    int b = 10;
    std::array<int*, 2> arr = {&a, &b};
    test(arr);

    // well-formed
    *arr[0] = 42;

    return 0;
}

我不认为有一种方法可以达到你提到的特定要求。但是，传递解引用的整数是可以的，通过：

int modify(const int a)
{
    return a;
}

int main()
{
    int a = 5;
    int b = 10;
    std::array<int *, 2> arr = {&a, &b}; // with const
    modify(*(arr[0]));      // Because this is not possible.
}

我不能在函数中修改它的值。虽然你可以简单地使用一个函数来处理这个问题，但它并不是那么开箱即用。

function A {
    change array to const int array
    pass const array into the function
}

或者稍微修改数组类中的运算符函数。（矫枉过正）