까다로운 동적 객체 및 포인터

Question

포인터를 설정하는 방법에 어떤 문제가 있는지 이해하는 데 문제가 있습니다. 나는 다음을 따라 뭔가 일을하려고 오전 :

matrix[0] = new Array<T>(columnSize); 

를하지만 컴파일되지 않습니다. 문제는 matrix [0]이 참조를 반환하고 새로운 Array (columnSize)를 할당하는 것이 합법적이지 않다는 것입니다.

여기에 내가 아래에있는 내 모든 코드를 부착 오류

/Users/Ezequiel/desktop/wow/Matrix.h: In constructor ‘Matrix<T>::Matrix(size_t, size_t) [with T = int]’: 
main.cpp:8: instantiated from here 
/Users/Ezequiel/desktop/wow/Matrix.h:18: error: invalid conversion from ‘Array<int>*’ to ‘long unsigned int’ 
/Users/Ezequiel/desktop/wow/Matrix.h:18: error: initializing argument 1 of ‘Array<T>::Array(size_t) [with T = Array<int>*]’ 

입니다.

// Array.h 

#ifndef ARRAY_H 
#define ARRAY_H 

#include <string> 
#include <iostream> 
#include <algorithm> 

template<class T> 
    class Array { 
     private: 
      T* elements; 
      size_t low, high; 
      void init(const size_t, const size_t); 
      void copy(const Array<T>&); 

     public: 
      size_t size; 
      Array(); 
      ~Array(); 
      Array(const size_t); 
      Array(const size_t, const size_t); 
      Array(const Array<T>&); 

      T& operator[](const size_t); 
      Array<T>& operator=(const Array<T>&); 

      template<class X> 
       friend std::ostream& operator<<(std::ostream&, const Array<X>&); 
    }; 

template<class T> 
    void Array<T>::init(const size_t low, const size_t high) { 
     if (high < low || (high - low + 1 <= 0)) { 
      std::cout << "An error was found in the bounds passed to the constructor.\n"; 
      exit(1); 
     } 

     size = high - low + 1; 
     elements = new T[size]; 

     this->low = low; 
     this->high = high; 
    } 

template<class T> 
    void Array<T>::copy(const Array<T>& someArray) {   
     delete[] elements; 

     if (someArray.size) { 
      elements = new T[someArray.size]; 
      std::copy(someArray.elements, someArray.elements + someArray.size, elements); 
      low = someArray.low; 
      high = someArray.high; 
      size = someArray.size; 
     } else { 
      size = 0; 
      elements = 0; 
      low = high = -1;  
     } 
    } 

template<class T> 
    Array<T>::Array() { 
     size = 0; 
     elements = 0; 
     low = high = -1; 
    } 

template<class T> 
    Array<T>::Array(const size_t size) { 
     init(0, size - 1); 
    } 

template<class T> 
    Array<T>::Array(const size_t low, const size_t high) { 
     init(low, high); 
    } 

template<class T> 
    Array<T>::~Array() { 
     delete[] elements; 
    } 

template<class T> 
    Array<T>::Array(const Array<T>& someArray) { 
     copy(someArray); 
    } 

template<class T> 
    Array<T>& Array<T>::operator=(const Array& someArray) { 
     if (this == &someArray) { 
      return *this; 
     } 

     copy(someArray); 

     return *this; 
    } 

template<class T> 
    T& Array<T>::operator[](const size_t index) { 
     if (index < low || index > high || size <= 0) { 
      std::cout << "The index " << index << " goes out of bounds.\n"; 
      exit(1); 
     } 
     return elements[index - low]; 
    } 

template<class X> 
    std::ostream& operator<<(std::ostream& os, const Array<X>& someArray) { 
     if (someArray.elements) { 
      for (size_t i = 0; i < someArray.size - 1; ++i) { 
       os << someArray.elements[i] << ", "; 
      } 
      os << someArray.elements[someArray.size - 1]; 
     } else { 
      os << 0; 
     } 
    } 

#endif 

// Matrix.h 
#include "Array.h" 

template<class T> 
    class Matrix { 
     private: 
      Array< Array<T>* > *matrix; 
      size_t rowSize, columnSize; 
     public: 
      Matrix(const size_t rowSize, const size_t columnSize); 
    }; 

template<class T> 
    Matrix<T>::Matrix(const size_t rowSize, const size_t columnSize) { 
     matrix = new Array< Array<T>* >(rowSize); 

     // Compiles perfectly fine, except after I uncomment this line: 
     // matrix[0] = new Array<T>(columnSize); 

     this->rowSize = rowSize; 
     this->columnSize = columnSize; 
    } 

Answer 1

matrix는 Array<Array<T>*> 없습니다. Array<Array<T>*>* - Array<Array<T>*>에 대한 포인터입니다. 즉, matrix[0] (*matrix으로 작성된 것이 좋음)은 Array<Array<T>*>입니다.

new[] 대신 matrix을 new을 통해 할당합니다. 하나의 개체 만 할당됩니다. matrix[0]을 사용하여이 단일 객체를 참조 할 수 있지만 new으로 할당하므로 역 참조 연산자를 사용하는 것이 좋습니다. matrix[0]을 사용하면 귀하 또는 귀하의 코드 독자가 matrix[1] 일 수 있다고 생각할 수 있습니다. 존재하지 않는다. 당신은, 루프에서

(*matrix)[idx] = new Array<T>(columnSize); 

주를 할당하는 경우

이 주석 처리 된 문을 해결하는 방법은

(*matrix)[0] = new Array<T>(columnSize); 

을 사용하는 것입니다 그의 I, J 요소를 참조 행렬은 (*matrix)[i][j]을 통해 행해진 다.

당신이 matrix[0]를 사용하여 주장하는 경우에 당신은 J의 에게 난을 참조하는 행렬의 요소를

matrix[0][idx] = new Array<T>(columnSize); 

가 할당하는 데 사용할 필요 matrix[0][i][j]합니다.