Question

我需要知道，对于所有编译器，以下代码中&N == &N_neg[MAXN]是否有保证。

int N_neg[MAXN], N[MAXN]; // defined in the global scope!
T<N> t; // so I can access N[i] (for i < 0) inside T

如果是这样，我已经完成了，这就是我所需要的。 如果没有，请阅读下面的完整问题。

注意：这适用于编程竞赛仅，因此不要担心可维护性。我更关心的是让T易于理解。

我有以下定义：

template<int* B> class T { ... }

在T内，我访问B[-n]，其中n > 0。所以，这就是我想要做的事情：

#define MAXN 1000
int N[2*MAXN];
T<N + MAXN> t;

根据编译器的说法，这是不允许的。 cppreference甚至有一个例子说明不工作，并且我已经在其他地方搜索了解决方案（还没有找到）。我确实理解模板是如何工作的，而且我知道（以及为什么）在编译期间必须知道每个模板参数的值，并且N的地址仅在以后链接期间才知道。

有什么建议吗？

以下是完整代码（以防有人根据问题提出任何建议）：

template<int M, int B[]> struct Hash {
    int h; Hash(int h = 0): h(h) {}
    int disp(int i) { return B[i]; }
    Hash concat(int ch, int i) { return (h + (ll) ch * B[i]) % M; }
    Hash subtract(int hl, int i) { return (ll) (h - hl + M) * B[-i] % M; }
    static void genBase(int n, int b) {
        B[0] = 1, B[-1] = powlg(b, M-2, M); // b^(-1) % M = b^(M-2) % M
        for (int i = 1; i < n; i++)
            B[i] = (ll) B[i-1] * b % M, B[-i] = (ll)B[-i+1] * B[-1] % M;
    }
};

Answer 1

如果对所有编译器保证&N == &N_neg[MAXN]

绝对不保证。 C ++标准没有强制要求变量的相对内存布局。事实上，它对内存布局的限制很少。

在某些情况下，技术上甚至无法保证N和N_neg不会被编译器优化掉（尽管取其地址通常会阻止这种情况发生）

要使布局顺序，您可以使用结构：

struct { int N_neg[MAXN], N[MAXN]; } arrays;

然后，理论上您可以将N_neg[MAXN]作为与N[0]相同的内存位置进行访问。但是，这是未定义的行为！ 可以为您工作，但我们假设您已分配给N_neg[MAXN]。编译器可能会认为N[0]未被修改，并优化了对它的任何访问，导致程序行为异常。

你可以通过声明两个数组volatile来解决这个问题，但是你会失去很多潜在的优化。

因此，我非常不愿意使用这种方法。坚持定义的行为几乎总是更好。

根据更新/发现的要求，这使您关闭只需要一个模板参数：

template <typename T, T&>
struct Hash;

template <std::size_t Size, typename T, T (&Array)[Size]>
struct Hash<T[Size], Array>
{
    // Your code here

private:
    static constexpr T *N = &Array[Size / 2];
};

实例化如下：

int N_backing[MAXN * 2];
Hash<decltype(N_backing), N_backing> hash;

由于N为constexpr，因此保证在编译时计算其值。

静态内存分配 - 它是按顺序分配的吗？

1 个答案: