动态分配的类对象

Question

我有一个简单的类，你可以在下面看到：

问题

1. 我可以在我的Playground 类构造函数中有这样的Playground(int aRow, int aColumn); 如果YES 在这种情况下我必须如何为行和列的元素分配内存？如果否为什么？
2. 为什么我不能写mPlayground[0][0] = 0，我该怎么做？如果可以的话。

Playboard.h

#pragma once
#ifndef PLAYBOARD_H
#define PLAYBOARD_H

class Playground
{
public:
    Playground()
    {       
    }
};

class Playboard
{
public:
    Playboard();
    ~Playboard();

private:
    Playground** mPlayground;
    int mRows;
    int mColumns;

public:
    void Initialize(int aRow, int aColumn);
};

#endif /** PLAYBOARD_H */

Playboard.cpp

#include "Playboard.h"
Playboard::Playboard()
{
    mPlayground = 0;
}

void Playboard::Initialize(int aRow, int aColumn)
{
    // Set rows and columns in order to use them  in future.
    mRows = aRow;
    mColumns = aColumn;

    // Memory allocated for elements of rows.
    mPlayground = new Playground*[aRow];
    // Memory allocated for elements of each column.
    for (int i=0; i<aRow; i++)
        mPlayground[i] = new Playground[aColumn];
}

Playboard::~Playboard()
{
    // Free the allocated memory
    for (int i=0; i<mRows; i++)
        delete[] mPlayground[i];
    delete[] mPlayground;
}

Answer 1

1a 我可以在我的 Playground 类构造函数中有这样的 Playground(int aRow, int aColumn);

是的，很简单：

class Playground {
    int x, y;
    Playgrown(int aX, int xY) : x(aX), y(aY) {}
};

1b 如果是，我必须如何为行和列的元素分配内存？如果没有，为什么？

您根本不必分配内存。 Playground 不包含指针，因此不需要分配。

2 为什么我不能写mPlayground[0][0] = 0，我该怎么做？如果可以的话当然可以。

因为您没有为Playground 重载赋值运算符。例如，

class Playground {
    …
    // Sample operator=. You'll need to implement its semantics
    void operator=(int) {}
};

---

您不能使用new 初始化数组的成员。你也许可以这样做：

{
    mPlayground[i] = new Playground[aColumn];
    for(int x = 0; x < i; x++)
      mPlayground[i][x] = Playground(3,4);
}

Answer 2

1) 是的：

Playground(int aRow, int aColumn)
{
}

2) 编辑：抱歉，我认为这是一个更复杂的问题。我将在此处留下以下答案以供将来参考。为了能够写mPlayground[0][0] = 0，你需要重载

Playground& Playground::operator = ( int x );

旧答案：

为了能够从Playboard 类访问Playground 对象，您可以重载() 运算符并调用：

Playground Playboard::operator()(int r, int c)
{
    return mPlayground[r][c];
}

//...
Playboard p;
p(x,y);

或[] 运算符：

Playground* Playboard::operator[] (int r)
{
    return mPlayground[r];
}

 //...
 Playboard p;
 p[x][y];