Question

我最近开始使用C ++;我是一个业余爱好程序员，我知道一些Python。

我编写了一条小蛇。我想插入另一条由计算机引导的蛇。

我决定把蛇可能的方向放在枚举中：

enum directions{UP, DOWN, RIGHT, LEFT, IN, OUT, FW, RW,NONE};

void fill_map(std::map<directions,V4> &map_vec);

void fill_map(std::map<int, directions*> &map_dir);

void fill_map(std::map<directions,directions> &map);

并映射所需函数的枚举：

void fill_map(std::map<directions,V4> &map_vec){
    map_vec[UP] = V4(0,1,0,0);
    map_vec[DOWN] = V4(0,-1,0,0);
    //others

  }

 void fill_map(std::map<directions, directions> &map){
    map[UP]= DOWN;
    map[DOWN]= UP;
    //others
  }


void fill_map_axis(std::map<int, directions*> &map_dir){
    directions array_x[2] = {RIGHT,LEFT};
    map_dir[0] = array_x;

    directions array_y[2] = {UP,DOWN};//store the array
    map_dir[1] = array_y;

    directions array_z[2] = {FW,RW};//store the array
    map_dir[2] = array_z;

    directions array_w[2] = {IN,OUT};//store the array
    map_dir[3] = array_w;

}

在snake构造函数中调用fill_map函数基本上我想在fill_map_axis中做的是映射一个对应于坐标索引的整数（0 coord x，1 coord y etc），并映射沿这些轴移动的两个方向。所以我存储了两个方向的数组。

现在我调用函数：

directions SnakeCPU::find_dir(V4 point){
    //point is the target point
    directions dir;
    int index = get_coord_index(point); //get the index where to move
    double diff = head_pos[index]-point[index]; //find the difference between the head and the target point

    directions* axis = dir_coords[index]; //call the map containing the directions stored in an array.

    if(diff<0.){

        dir = *axis; //use the first
    }
    else if(diff>0.) {
        axis++;
        dir = *axis; //use the second
    }
    else{
        dir = NONE;
    }

    return dir;
}

虽然地图是在Snake构造函数中初始化的，但似乎指针轴的返回值是一个随机内存块。

所以我的问题：您是否在代码中看到错误？我是否使用指针轴感觉？

我真的不是指针专家;在Python中，地图使用如下字典进行实例化：

dir_coords = {0:[LEFT,RIGHT], ...}

所以我只需要打电话：

axis = dir_coords[index]
dir = axis[0]
#or
dir = axis[1]

编辑：

Snake构造函数：

Snake::Snake()
{    
    fill_map(dir_vectors);
    fill_map(dir_coords);
    fill_map(opposite_dir);
    head_pos = V4(0.,0.,0.,0.);
    //other stuff...
}

Answer 1

只是一拍蓝光，我就是这样设计的。

#include <map>

enum EDirection { NONE = 0, UP, DOWN, RIGHT, LEFT, IN, OUT, FW, RW };

typedef std::map<EDirection, V4>           DirectionMap;
typedef std::pair<EDirection, EDirection> DirectionPair;
typedef std::map<int, DirectionPair>            PairMap;

extern const DirectionMap map_vec {
  { UP,   (0, 1, 0, 0) },
  { DOWN, (0,-1, 0, 0) },
  // ...
};   // using C++11 initialization lists for convenience

extern const PairMap map_dir {
  { 0, { RIGHT, LEFT } },
  { 1, { UP, DOWN }    },
  // ...
};

在这里，我决定制作map_vec和map_dir全局常量，因为我收集的内容基本上就是它们。为了初始化它们，我依赖于新的C ++ 11初始化语法。如果这不是一个选项，我们也可以用传统方式填充地图：

PairMap map_dir;
map_dir.insert(std::make_pair(0, DirectionPair(RIGHT, LEFT)));
map_dir.insert(std::make_pair(1, DirectionPair(UP, DOWN)));
// ...

DirectionMap map_vec;
map_vec.insert(std::make_pair(UP,   V4(0, 1, 0, 0)));
map_vec.insert(std::make_pair(DOWN, V4(0,-1, 0, 0)));
// ...

（是的，你也可以写map_dir[0] = DirectionPair(RIGHT, LEFT)'。我不喜欢方括号，但是，根据我的口味，他们觉得太暴力了。）

Answer 2

正如Kerrek所说，你用自动范围的变量填充map_dir，这意味着它们会在函数结束时自动销毁。

void fill_map_axis(std::map<int, directions*> &map_dir){
    //This variable will be destroyed when the function ends
    directions array_x[2] = {RIGHT,LEFT};  
    map_dir[0] = array_x; //should have a warning at least, probably not compile

你可能想要的是地图中的实际方向

void fill_map_axis(std::map<int, std::pair<directions, directions> > &map_dir){
    //This variable will be destroyed when the function ends
    std::pair<directions, directions> array_x = {RIGHT,LEFT};  
    map_dir[0] = array_x; //makes a copy

将整数映射到数组

2 个答案: