0

「スポット」クラスの2D固定サイズオブジェクト配列があります。スポットマップ[行][列];//行と列は動的に変更された整数です。関数に渡します。boolisFilled（int row、int col、Spot [ row] [col]）{}関数を定義する方法は？この配列を削除する方法は？私のコードを参照してください。ご協力いただきありがとうございます。

Spot.h

    #ifndef SPOT_H
#define SPOT_H

class Spot
{
private:
    bool isBunny;
    int nextCycle;
public:
    static const int UP = 0;
    static const int RIGHT = 1;
    static const int DOWN = 2;
    static const int LEFT = 3;
    static const int SLEEP = 4;

    virtual void setSpot(bool newIsBunny);
    Spot();
    ~Spot();
    virtual int getNextCycle();
    virtual void setNextCycle();
    virtual bool getIsBunny();
    virtual void makeBunny();
};

void Spot::setSpot(bool newIsBunny)
{
    isBunny = newIsBunny;
    nextCycle = UP;
}

Spot::Spot()
{
    isBunny = false;
    nextCycle = UP;
}

Spot::~Spot()
{
}

void Spot::setNextCycle()
{
    if (nextCycle != SLEEP)
    {
        nextCycle++;
    }
}

int Spot::getNextCycle()
{
    return nextCycle;
}

bool Spot::getIsBunny()
{
    return isBunny;
}

void Spot::makeBunny()
{
    if (!isBunny)
        nextCycle = UP;
    isBunny = true;
}


#endif  /* SPOT_H */


Bunny.cpp



#include "Spot.h"
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <boost/algorithm/string.hpp>


using namespace std;


static string line;
static ifstream inFile;
static ofstream outFile;
bool isFilled(int x, int y, Spot **myMap);

int main () {
  int numSims = 0;
  inFile.exceptions ( ifstream::failbit | ifstream::badbit );

  try {
    inFile.open ("/home/mike/Desktop/input.txt");
    outFile.open ("/home/mike/Desktop/output.txt");
   // while(!inFile.eof())
      {

         getline (inFile,line);
        numSims= atoi(line.c_str());
       //cout<<"numSims: "<<numSims<<endl;
        for (int i = 0;i < numSims;i++)
            {
                int minPerCycle = 1;
                getline (inFile,line);
                minPerCycle= atoi(line.c_str());

            //cout << "minPerCycle: "<<minPerCycle <<endl;

                int row = 0;
                int col = 0;
                    getline (inFile,line);
                    std::vector<std::string> xy;
                    boost::split(xy, line, boost::is_any_of(" "));
                    row=atoi(xy.at(0).c_str());
                    col=atoi(xy.at(1).c_str());
                    //cout <<"row: "<< row<<endl;
                    //cout << "col: "<<col<<endl;


                    Spot** myMap = new Spot* [col];
                    for(int i = 0; i < col; ++i)
                        myMap[i] = new Spot [row];

                    //std::vector<std::vector<Spot> > myMap(x, std::vector<Spot>(y));
                    for (int i = 0;i < row;i++)
                            {
                                getline (inFile,line);
                                //cout<<line<<endl;
                                for (int j = 0;j < col;j++)
                                {
                                    if (line[j] == 'B')
                                    {
                                        myMap[i][j].setSpot(true);

                                    }
                                    else
                                    {
                                        myMap[i][j].setSpot(false);

                                    }
                                }
                            }
                int numCycles = 1;

                if (isFilled(row,col,myMap))
                {
                    numCycles = 0;
                }

                while (!isFilled(row,col,myMap))
                {
                    numCycles++;

                    for (int j = 0;j < row;j++)
                    {
                        for (int k = 0;k < col;k++)
                        {
                            if (myMap[j][k].getIsBunny())
                            {       //cout<< j<<" "<<k<<" " <<"true"<<endl;
                                    switch (myMap[j][k].getNextCycle())
                                    {
                                        case Spot::UP :
                                            if (j>0)
                                            myMap[j-1][k].makeBunny();
                                            break;
                                        case Spot::RIGHT :
                                            if (k<col-1)
                                            myMap[j][k + 1].makeBunny();
                                            break;
                                        case Spot::DOWN :
                                            if (j<row-1)
                                            myMap[j+ 1][k].makeBunny();
                                            break;
                                        case Spot::LEFT :
                                            if (k>0)
                                            myMap[j][k - 1].makeBunny();
                                            break;
                                    }
                                    myMap[j][k].setNextCycle();
                                }
                            //cout<< j<<" "<<k<<" " <<"outside"<<endl;
                        }
                    }

                }
                int time = numCycles*minPerCycle;
                outFile<<"It took " <<time <<" minutes for the bunnies to take over the world!\n";
                cout<<"It took " <<time <<" minutes for the bunnies to take over the world!\n";
                for(int i=0; i < col; i++) {
                   delete [] myMap[i];
                }
                delete myMap;

            }
      }

       inFile.close();
       outFile.close();

}
  catch (ifstream::failure e) {
    cout << "Exception opening/reading file";
  }

  return 0;
}


bool isFilled(int row, int col,Spot **myMap)
{
    for (int i = 0;i < row;i++)
    {
        for (int j = 0;j < col;j++)
        {
            if (!myMap[i][j].getIsBunny())
            {
                //cout<<"true ";
                return false;

            }
            //else
            //  cout<<"false ";


        }
        //cout<<endl;

    }
    return true;
}
4

3 に答える 3

0

ポインタで渡すことを試みなければなりませんか？

static bool isFilled(int row, int col,Spot** yourMap)

Spot myMap[row][col]コンパイラによって受け入れられ、実行時に設定されるように見えるrowかどうかはわかりません。col

次の方法でメモリを割り当てる必要がある場合があります

Spot** myMap = new Spot* [col];
for(int i = 0; i < col; ++i)
    myMap[i] = new Spot [row];

メモリを削除するには、同様のものを使用する必要がありますがfor loop、呼び出すことを忘れないでくださいdelete []

于 2012-09-26T07:47:57.970 に答える
0

2D配列への参照を、2D配列を使用するメソッドに送信するだけでよいと思います。

bool isFilled(int row, int col, Spot &m){  // if you want a fix position in the array
 // Code
}

配列を削除する場合は、削除演算子を使用する必要があります。

まず、ポインタ配列が指すすべての配列を削除する必要があります。

for(int i=0; i < size; i++) {
   delete [] spot[i];  // Depends on what you have called the array
}

次に、ポインタの配列を削除する必要があります

delete [] spot;
于 2012-09-26T07:48:54.957 に答える
0

myMap[row][col]を見つけます。

これは合法的なC++コードではありません。これはC99で実行できますが、C++では実行できません。

C++には2つの基本的な選択肢があります。

  1. 2D配列であるかのように扱う1次元配列を使用します。
  2. 隣接する2D配列の代わりに、不規則な2D配列を使用します。

1次元配列を使用する主な利点は、高速であるということです。スピードが必要な場合は、これが最適な方法です。グラフィックプログラマーは、その速度が必要なため、このアプローチをよく使用します。欠点は、2Dインデックスを単一のインデックスに変換する必要があることです。たとえば、（行のメジャーオーダー）または（列のメジャーオーダー）map[i][j]になる場合があります。map[i*col+j]map[i+j*row]

ジャグ配列を使用する主な利点は、インデックス付けが自然であるということです。欠点は、管理するメモリがさらに多くなり、アクセスがかなり遅くなることです。フラット化された配列では、アクセスは少数の整数演算と単一のメモリルックアップで構成されます。不規則な配列には、2つのメモリルックアップが必要です。

これはC++なので、マップをクラスにすることをお勧めします。メモリを割り当てる行と列のサイズを持つデフォルト以外のコンストラクタ、クリーンアップするデストラクタ（必要な場合）を提供します。基盤となるストレージメカニズムとして使用する場合std::vectorは、割り当てとクリーンアップが行われます。operator()マップへのインデックスメカニズムとして機能するオーバーロードを提供します。これで、マップを表すために使用しているメカニズムが非表示になります。ベクトルのベクトルから始めることができ、それが遅すぎる場合は、フラット化された配列アプローチに切り替えます。

于 2012-09-26T08:26:44.360 に答える