Toán tử [] Quá tải trong mảng đa chiều C++

Question

Khi tôi gọi: a7 [0] [1] [100];

Tôi có thể lấy chỉ mục đầu tiên '0' trong toán tử [] nhưng dưới dạng chỉ mục tôi sẽ không thể lấy các giá trị chỉ mục 1 và 100 khác theo cách đệ quy. Làm thế nào tôi có thể sử dụng toán tử [] để thu được các giá trị chỉ mục folowing đệ quy. Trong ví dụ này cho mảng 3 chiều, toán tử [] chỉ được gọi một lần cho thứ nguyên đầu tiên là '0'.

My Mã số Ví dụ:

template <class T, unsigned ... RestD> struct array; 

template <class T, unsigned PrimaryD> 
struct array <T, PrimaryD> { 
    typedef T type[PrimaryD]; 

    type data; 

    T& operator[] (unsigned i) { 
     return data[i]; 
    } 
}; 

template <class T, unsigned PrimaryD, unsigned ... RestD> 
struct array <T, PrimaryD, RestD...> { 
    typedef typename array<T, RestD...>::type OneDimensionDownArrayT; 
    typedef OneDimensionDownArrayT type[PrimaryD]; 

    type data; 

    OneDimensionDownArrayT& operator[] (int i) { 
     OneDimensionDownArrayT& a = data[i]; 
     return a; 
    } 
}; 

int main() { 

    array<int, 1, 2, 3> a7 {{{{1, 2, 3},{4, 5, 6}}}}; 
    a7[0][1][2] = 100; //=>won't recursively go through operator[] 
        //I want to recursively obtain 0, 1 and 2 as index values 

    a7[0][1][100] = 100; //also works correctly. 
    std::cout << a7[0][1][100] << std::endl; 

    return 0; 
} 

Answer 1

Các lỗi ở đây thực sự là một chút tinh tế, thay đổi dòng

typedef typename array<T, RestD...>::type OneDimensionDownArrayT; 

để

typedef array<T, RestD...> OneDimensionDownArrayT; 

Lý do cho điều này là bởi vì array<int, 1, 2, 3>::type bình đẳng array<int, 2, 3>::type bằng array<int, 3>::type là int. Cuối cùng, bạn kết thúc với array<int, 1, 2, 3>::OneDimensionDownArrayT bằng int[2][3]. Đây là lý do tại sao bạn chỉ đi xuống một cấp trong toán tử quá tải của bạn [], bởi vì nó trả về một mảng ints thực tế. Bạn có thể tự mình xem nội dung này bằng cách thêm phương thức chính của mình:

 auto & e1 = a7[0]; 
     auto & e2 = e1[0]; 
     auto & e3 = e2[1]; 
     auto & e4 = e3[2]; 
     e4 = 100; 

thay vì truy cập cùng một lúc. Sau đó, bước qua với trình gỡ lỗi và kiểm tra các loại e1-e4. e1 sẽ có loại int (&) [2][3] thay vì array<int, 2, 3> &.

Để phân bổ chúng trên đống thay vì trên ngăn xếp, trong lớp của bạn khai báo con trỏ đến OneDimensionDownArrayT thay vì mảng của chúng, xác định các hàm tạo và một desctructor sẽ chăm sóc phân bổ/deallocating mảng của bạn. Nó có thể trông giống như sau:

template <class T, unsigned PrimaryD, unsigned ... RestD> 
    struct array <T, PrimaryD, RestD...> { 
     typedef typename array<T, RestD...>::type OneDimensionDownArrayT; 

     array():data(new OneDimensionDownArrayT[PrimaryD]){} 
     ~array() { 
      delete[] data; 
     } 

     OneDimensionDownArrayT * data; 

     OneDimensionDownArrayT& operator[] (int i) { 
      OneDimensionDownArrayT& a = data[i]; 
      return a; 
     } 
    }; 

Bạn cũng sẽ muốn xác định hàm tạo bản sao, di chuyển hàm tạo và toán tử gán cho lớp của bạn. Việc triển khai này sẽ chiếm không gian ít hơn nhiều, nhưng tổng dung lượng bộ nhớ hơi nhiều hơn vì bạn cũng cần không gian cho các con trỏ cũng như các mảng.

Answer 2

Nếu bạn muốn sử dụng [] toán tử liên tiếp một mảng đa chiều, thì mỗi [] phải trả về mảng (một ít) hai chiều.

Nếu loại mảng đa chiều của bạn là:

template <class Type, int dim> MArray; 

Sau đó, một MArray<SomeType, n>::operator[] phải trả lại một MArray<SomeType, n-1>. Với một trường hợp đặc biệt cho mảng 1-D đặc biệt của bạn trả về một đối tượng (tốt nhất là tham chiếu) hoặc một mảng 2-D trả về một mảng 1-D riêng. Ví dụ này sử dụng ký pháp quá đơn giản, nhưng điều quan trọng là một n-D [] -operator trả về mảng (n-1) -D.