Question

这是我目前正在使用的代码

template <class T>
float Knapsack<T>::knapTable()
{
  const int MAXSIZE = 40000;
  int temps = nObjects - 1;
  float** memoize = new float*[MAXSIZE];

  for(int y = 0; y < weight[nObjects]; y++)
    memoize[nObjects][y] = 0;

  for(int y = weight[nObjects]; y < knapCap; y++)
    memoize[nObjects][y] = price[y];

  for(int i = temps; i >= 1; i--)
  {
    for(int y = weight[i]; y < knapCap; y++)
      memoize[i][y]= max(memoize[i+1][y], (memoize[i+1][y-weight[i]]+price[i]));
  }

  return memoize[1][nObjects];

}

由于某些原因，我不断收到错误：knapsack.hpp：68：64：error：数组下标的类型'float * [float]'无效。

这就是这一行：float ** memoize = new float * [MAXSIZE];

由于某些原因，编译器似乎将MAXSIZE识别为float，它是一个const int。

我有办法解决这个问题吗？

编辑了更多代码头文件 #ifndef KNAPSACK_H #define KNAPSACK_H

#include <stdexcept>
#include <assert.h>
#include <iostream>
#include <limits.h>
using namespace std;

template <class T>
class Knapsack
{
  private:
    float knapPrice;
    int knapCap, nObjects;
    float weight[40000];
    float price[40000];
  public:

    Knapsack(): knapPrice(0), knapCap(0), nObjects(0) {}
    ~Knapsack() {knapPrice = 0; knapCap = 0;}

    float knapFull (int position, int currentCap);

    float knapTable ();

    float greedyKnap (int currentCap);

    float max(float noAdd,float addOb);

    void printPrice();
    //valueized and valued are modified versions of mergeSort and merge
    //designed to sort two arrays by a fraction of the two.
    void valueize(int ini, int last);

    void valued(int ini, int middle, int last);

    void fillWandP();

    void setNObjects(int n);

    void setKnapCap(int boom);
};
#include "knapsack.hpp"
#endif

主要功能//虽然我不认为这会影响它 #include“sortClass.h” #include“knapsack.h” ＃包括＃包括＃包括＃包括使用namespace std;

//mergeSort main;
int main()
{
    Knapsack<float> a;
    float sacked = 0;

    int nO = 18;
    int cap = 700;
    a.setNObjects(nO);

a.setKnapCap(cap);

    a.fillWandP();

    for(int b = 0; b <3800000; b++)//for getting good times
  sacked = b;

    int startAll = clock()*1000000;
    sacked = a.knapFull(1, cap);
    int knapped = clock()*1000000;
    int boom = a.knapTable();
    int tabled = clock()*1000000;
    a.valueize(1, cap);
    int andDone = a.greedyKnap(cap);
    int greedified = clock()*1000000;
    cout<<startAll<<endl;

    greedified = greedified - tabled;
    tabled = tabled - knapped;
    knapped = knapped - startAll;
    cout<<"Recursion profit:"<<sacked<<" Time: "<<knapped<<endl;
    cout<<"Memoization profit:"<<boom<<" Time: "<<tabled<<endl;
    cout<<"Greedy profit: "<<andDone<<" Time: "<<greedified<<endl;



    return 0;
}

Answer 1

weight在float weight[40000]中声明为class Knapsack。

然后使用weight元素作为memoize函数中knaptable()的索引：

memoize[i][y]= max(memoize[i+1][y], (memoize[i+1][y-weight[i]]+price[i]));
//                                                  ^^^^^^^^^

对于记录，这是g ++ 4.6.1产生错误的行;它没有指向声明memoize的行。

Answer 2

不一定相关，但您没有正确使用数组/指针。当你调用float** memoize = new float*[MAXSIZE]时，你创建了第一级指针，但是你只有一个指针数组，而不是一个双数组。您还需要将每个memoize[i]初始化为数组。

话虽如此，看起来你应该为你的memoize数组分配内存。只需将其声明为

float memoize[SIZE][SIZE];

这样，您就不必担心内存清理或其他任何问题，而且它更有意义。

Answer 3

  for(int i = temps; i >= 1; i--)
  {
    for(int y = weight[i]; y < knapCap; y++)
      memoize[i][y]= max(memoize[i+1][y], (memoize[i+1][y-weight[i]]+price[i]));
  }

y-weight[i]是一个浮点数。这是你的问题。

一旦你解决了这个问题，你会发现你仍然有一个问题，你正在分配一个指针数组，但你还需要为每个指针分配第二维才能使用那个阵列。

有些事情：

float** memoize = new float*[MAXSIZE];

for(size_t i = 0; i < MAXSIZE; ++i)
{
  memoize[i] = new float[MAXSIZE];
}

Answer 4

我想也许你只需要为第二个指针分配内存，比如

float** memoize = new float*[MAXSIZE];
    memoize=(float**)malloc(sizeof(float*)*MAXSIZE);
    for(int i=0;i<MAXSIZE;i++)
    {
        memoize[i]=(float*)malloc(sizeof(float)*MAXSIZE);
    }

在2维数组下标中将整数识别为浮点数

4 个答案: