Question

我正在为univ工作，因为有些部分不是很好解释我遇到了一些问题，我的结构和我的构造函数，它必须是动态的，但我得到了一个错误。一些帮助非常感谢谢谢。 .H：

const int days=31;
const int exp=6;

struct Array{
int days;
int exp;
int **M;
};

的.cpp：

void constr(Array &loc){
//Construct of 31*6 Matrix, were 31 nr. of days and 6 specific types:
//0-HouseKeeping, 1-Food, 2-Transport, 3-Clothing, 4-TelNet, 5-others
loc.days = days;
loc.exp = exp;
loc.M=malloc(loc.days*sizeof(int*));
for(int i=0; i<loc.days;i++ ){
    loc.M[i] = malloc(loc.exp*sizeof(int));
    for (int j = 0; j< loc.exp; j++){
        loc.M[i][j] = 0;
    }
}
}

错误：

..\src\structs.cpp: In function 'void constr(Array&)':
..\src\structs.cpp:7:36: error: invalid conversion from 'void*' to 'int**'    [-fpermissive]
..\src\structs.cpp:9:40: error: invalid conversion from 'void*' to 'int*' [-fpermissive]

Answer 1

由于您在评论中要求使用C ++构造函数...请参阅下面的代码。我还用C ++向量替换了你的二维C风格数组。我在相关的行中添加了代码注释：

Array.h：

#pragma once

#include <vector>

struct Array
{
    // this is a c++ constructor declaration
    Array(int daysParam, int expParam);

    int days;
    int exp;

    // use a vector of vectors instead allocating with new or malloc
    // it is easier to initialize and the compiler will clean it up for you
    std::vector<std::vector<int> > M;
};

Array.cpp：

#include "Array.h"

// Array constructor definition with initializer list
// all data members are initialized here by invoking their constructor
Array::Array(int daysParam, int expParam)
    : days(daysParam), 
      exp(expParam), 
      M(daysParam, std::vector<int>(expParam, 0))
{
}

使用Array（Program.cpp）的示例：

#include "Array.h"

int main()
{
    // create a new Array, using the c++ constructor
    Array myArray(31, 6);

    // access elements in the 2-dimensional array
    int singleValue = myArray.M[15][3];

    return 0;
}

我强烈建议您阅读book about C++

Answer 2

因为这是C ++：

loc.M = new int*[loc.days];
for(int i=0; i<loc.days;i++ ){
   loc.M[i] = new int[loc.exp];
   for (int j = 0; j< loc.exp; j++){
       loc.M[i][j] = 0;
   }
}

Answer 3

loc.M = (int**)malloc(loc.days*sizeof(int*));
loc.M[i] = (int*)malloc(loc.exp*sizeof(int));

Answer 4

请停止使用std :: vector＆gt;或者，更糟糕的T tab [] []用于表示2D数组。您应该使用1D数组来存储数据，使用索引数组来存储行指针。这样，您的数据仍然是连续的，您仍然可以有一个很好的语法。

  template<typename T>


class Array2D



{
    std::vector<T>  m_data;
    std::vector<T*> m_ptr;
    size_t m_iWidth;
    size_t m_iHeight;

    void Link(void)
    {
      for (unsigned int j = 0; j < m_iHeight; ++j)
        m_ptr[j] = &m_data[j * m_iWidth];
    }


  public:
    Array2D(void)
    {
    };
    Array2D(const size_t i_width, const size_t i_height) :
      m_iWidth(i_width),
      m_iHeight(i_height),
      m_data(i_width * i_height),
      m_ptr(i_height)
    {
      Link();
    }


    void Resize(const size_t niou_width, const size_t niou_height)
    {
      if (m_iWidth == niou_width && m_iHeight == niou_height)
        return;

      m_iWidth  = niou_width;
      m_iHeight = niou_height;

      m_data.resize(niou_height * niou_width);
      m_ptr.resize(niou_height);
      Link();
    }


    typename std::vector<T>::iterator begin(void)
    {
      return m_data.begin();
    }


    typename std::vector<T>::iterator end(void)
    {
      return m_data.end();
    }


    void assign(T value)
    {
      m_data.assign(m_iWidth * m_iHeight, value);
    }


    Array2D(const Array2D& a) :
      m_iWidth(a.m_iWidth),
      m_iHeight(a.m_iHeight),
      m_data(a.m_data)
    {
      m_ptr.resize(m_iHeight);
      Link();
    }


    Array2D& operator=(const Array2D a)
    {
      swap(*this, a);
      return *this;
    }

    template <typename U>
    friend void swap(Array2D<U>& first, Array2D<U>& second)
    {
      using std::swap;
      swap(first.m_iHeight, second.m_iHeight);
      swap(first.m_iWidth, second.m_iWidth);
      swap(first.m_data, second.m_data);
      swap(first.m_ptr, second.m_ptr);
    }

    ~Array2D()
    {
    };

    T* operator[](const size_t ligne)
    {
      return m_ptr[ligne];
    };
    const T* operator[](const size_t ligne) const
    {
      return m_ptr[ligne];
    };

    T& operator()(const size_t col, const size_t lig)
    {
      return m_ptr[lig][col];
    };
    const T& operator()(const size_t col, const size_t lig) const
    {
      return m_ptr[lig][col];
    };

C ++ struct构造函数错误

4 个答案: