C++ 随机顺序的if。。。其他声明。什么'；这是最有效的方法吗？

这样做的目的是使if语句的顶部不优于底部。我尝试为每个案例分配枚举值。然后从0到包含这些枚举元素的

std:：list myList

的大小中选择一个随机整数r。使用

it=std:：next（myList，r）

找到枚举值。然后，如果对应于该枚举值的if语句为

false

，则

myList.erase（it）

，并使用新的reduce

myList

重复该过程。它是有效的，而且一切看起来都很随意。但令人失望的是，它比我使用原始的

if-else

语句时慢得多。对更快的方法有什么建议吗？

---

下面是我的代码片段。有一群女孩。每个男人都会选择一个女孩，然后选择一个面对面的方向与他选择的女孩跳舞。但是，如果有人站在他想站的位置以获得他想要的面对方向，并非所有的面对方向都是可能的。如果不对

if-else

语句进行随机化，大多数人最终都会面对相同的方向，这是我不喜欢的

std::list<FacingDirection> guyFacingDirections = {Positive_x, Negative_x, Positive_y, Negative_y, Positive_xPositive_y, Positive_xNegative_y, Negative_xPositive_y, Negative_xNegative_y};
while (true)    {
    const int r = rand() % guyFacingDirections.size();
    std::list<FacingDirection>::iterator it = std::next(guyFacingDirections.begin(), r);        
    const FacingDirection facingDirectionChoice = *it;
    if (facingDirectionChoice == Positive_x)  // I decided that using switch (facingDirectionChoice) {case Positive_x: if (... was too clumsy in code and probably no more efficient.
    {  
        if (mainArea.locationAvailable (xChoice - 1, yChoice, zChoice))
            {guy->movesToNewLocation (xChoice - 1, yChoice, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);  // more efficient than 'guyFacingDirections.remove (Positive_x);'
    }
    else if (facingDirectionChoice == Negative_x)
    {  
        if (mainArea.locationAvailable (xChoice + 1, yChoice, zChoice))
            {guy->movesToNewLocation (xChoice + 1, yChoice, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);
    }
    else if (facingDirectionChoice == Positive_y)
    {  
        if (mainArea.locationAvailable (xChoice, yChoice - 1, zChoice))
            {guy->movesToNewLocation (xChoice, yChoice - 1, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);
    }
    else if (facingDirectionChoice == Negative_y)
    {  
        if (mainArea.locationAvailable (xChoice, yChoice + 1, zChoice))
            {guy->movesToNewLocation (xChoice, yChoice + 1, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);
    }
    else if (facingDirectionChoice == Positive_xPositive_y)
    {  
        if (mainArea.locationAvailable (xChoice - 1, yChoice - 1, zChoice))
            {guy->movesToNewLocation (xChoice - 1, yChoice - 1, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);
    }
    else if (facingDirectionChoice == Positive_xNegative_y)
    {  
        if (mainArea.locationAvailable (xChoice - 1, yChoice + 1, zChoice))
            {guy->movesToNewLocation (xChoice - 1, yChoice + 1, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);
    }
    else if (facingDirectionChoice == Negative_xPositive_y)
    {  
        if (mainArea.locationAvailable (xChoice + 1, yChoice - 1, zChoice))
            {guy->movesToNewLocation (xChoice + 1, yChoice - 1, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);
    }
    else if (facingDirectionChoice == Negative_xNegative_y)
    {  
        if (mainArea.locationAvailable (xChoice + 1, yChoice + 1, zChoice))
            {guy->movesToNewLocation (xChoice + 1, yChoice + 1, zChoice);  break;} 
        else
            guyFacingDirections.erase (it);
    }
    } 

std:：list guyFacingDirections={正的，负的，正的，正的，正的，负的，负的}；
while（true）{
const int r=rand（）%guyFacingDirections.size（）；
std:：list:：iterator it=std:：next（guyFacingDirections.begin（），r）；
const FacingDirection FacingDirection选项=*它；
if（facingDirectionChoice==Positive_x）//我决定使用switch（facingDirectionChoice）{case Positive_x:if（…在代码中太笨拙了，可能没有更高的效率。
{  
如果（mainArea.Location可用（xChoice-1，yChoice，zChoice））
{guy->movesToNewLocation（xChoice-1，yChoice，zChoice）；break；}
其他的
guyFacingDirections.erase（it）；//比“guyFacingDirections.remove（正_x）；”更有效
}
else if（facingDirectionChoice==负x）
{  
如果（mainArea.Location可用（xChoice+1，yChoice，zChoice））
{guy->movesToNewLocation（xChoice+1，yChoice，zChoice）；break；}
其他的
guyFacingDirections.erase（它）；
}
else if（朝向方向选择==正y）
{  
如果（mainArea.Location可用（xChoice，yChoice-1，zChoice））
{guy->movesToNewLocation（xChoice，ycchoice-1，zChoice）；break；}
其他的
guyFacingDirections.erase（它）；
}
else if（facingDirectionChoice==负值）
{  
如果（mainArea.Location可用（xChoice，yChoice+1，zChoice））
{guy->movesToNewLocation（xChoice，ycchoice+1，zChoice）；break；}
其他的
guyFacingDirections.erase（它）；
}
else if（facingDirectionChoice==正向）
{  
如果（mainArea.Location可用（xChoice-1，yChoice-1，zChoice））
{guy->movesToNewLocation（xChoice-1，ycchoice-1，zChoice）；break；}
其他的
guyFacingDirections.erase（它）；
}
else if（facingDirectionChoice==正x负）
{  
如果（mainArea.Location可用（xChoice-1，yChoice+1，zChoice））
{guy->movesToNewLocation（xChoice-1，yChoice+1，zChoice）；break；}
其他的
guyFacingDirections.erase（它）；
}
else if（facingDirectionChoice==负的正的）
{  
如果（mainArea.Location可用（X选择+1，Y选择-1，Z选择））
{guy->movesToNewLocation（xChoice+1，ycchoice-1，zChoice）；break；}
其他的
guyFacingDirections.erase（它）；
}
else if（facingDirectionChoice==负X负y）
{  
如果（mainArea.Location可用（xChoice+1，yChoice+1，zChoice））
{guy->movesToNewLocation（xChoice+1，yChoice+1，zChoice）；break；}
其他的
guyFacingDirections.erase（它）；
}
} 

好消息，你可以让这个程序运行得更快，让代码更短，更清晰，更容易移动……更不用说提供你想要的行为——一步到位：）

定义面向方向的列表：

class HandleFacingDirection {

   final int x;
   final int y;

   HandleFacingDirection(int x, int y) {
      this.x = x;
      this.y = y;
   }

   public boolean canFace(int xChoice, int yChoice, int zChoice) {
       if (mainArea.locationAvailable (xChoice + x, yChoice + y, zChoice)) {
            guy->movesToNewLocation (xChoice + 1, yChoice, zChoice);
            return true;
       } 
       return false;
   }
}

然后定义一个数组：

HandleFacingDirection[] directionHandlers = new HandleFacingDirections[] {
     new HandleFacingDirection(1, 0),
     new HandleFacingDirection(-1, 0),
     new HandleFacingDirection(0, 1),
     new HandleFacingDirection(0, -1)
}

在某处定义一个随机数生成器：

Random random = new Random();

现在，处理它的代码变成：

int offset = random.nextRandomInt(directionHandlers.length);
for (int i=0;i<directionHandlers.length;i++) {
   int index = i+offset;
   if (index > directionHandlers.length)
     index -= directionHandlers.length;
   if (directionHandlers[index].canFace(xChoice, yChoice, zChoice)) {
        break;
   }
}

int offset=random.nextRandomInt（directionHandlers.length）；
for（int i=0；i directionHandlers.length）
index-=directionHandlers.length；
if（directionHandlers[index].canFace（xChoice，yChoice，zChoice））{
打破
}
}

一般的想法是，您需要定义一个策略模式来确定某件事情是否有效

然后设置一个列表，其中包含该策略模式的所有不同排列

然后从一个随机位置开始在列表中循环

---

上面的代码可能需要一些整理，因为我刚刚将其组合在一起，它应该可以为您提供一些构建的基础。

是的，我尝试了以下方法：

struct Direction {
    int delta_x;
    int delta_y;
    // FacingDirection dir;  // if this information is also desired
};
static std::vector<Direction> directions = { {1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1} }; // static so that it only needs be initialized once
std::random_shuffle (std::begin (directions), std::end (directions));
//FacingDirection chosenDirection;  // use this if this information is needed (currently it is not)
for (const Direction& d: directions)  // Range-based for-loop MIGHT give faster performance.
{
    const int x = xChoice + d.delta_x;
    const int y = yChoice + d.delta_y;
    if (mainArea.locationAvailable (x, y, zChoice))
    {
        guy->movesToNewLocation (x, y, zChoice);
        //chosenDirection = d.dir;  // currently not needed for my program
        break;
    } 
}

结构方向{
int delta_x；
int delta_y；
//FacingDirection dir；//如果还需要此信息
};
静态std：：向量方向={1,0}，{-1,0}，{0,1}，{0，-1}，{1,1}，{1，-1}，{-1,1}，{-1,1}，{-1，-1}；//静态，因此只需初始化一次
std:：random_shuffle（std:：begin（方向），std:：end（方向））；
//朝向方向chosenDirection；//如果需要此信息，请使用此选项（目前不需要）
for（const Direction&d:directions）//基于范围的for循环可能提供更快的性能。
{
常数int x=xChoice+d.delta_x；
const int y=yChoice+d.delta_y；
如果（主区域位置可用（x、y、Z选择））
{
guy->movesToNewLocation（x，y，Z选择）；
//chosenDirection=d.dir；//我的程序当前不需要
打破
} 
}

感谢博尔赫斯的建议。

struct Direction {
    int delta_x;
    int delta_y;
    // FacingDirection dir;  // if this information is also desired
    bool canFace (Guy* guy, int x, int y, int z) const {  
        if (guy->LocationSituated()->locationAvailable (x + delta_x, y + delta_y, z))
        {
            guy->movesToNewLocation (x + delta_x, y + delta_y, z);
            return true;  // return std::make_pair (true, dir); if FacingDirection information is needed (currently it is not)
        }
        return false;   
    }
};
static std::vector<Direction> directions = { {1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1} }; // static so initialization only once
std::random_shuffle (std::begin (directions), std::end (directions));
for (const Direction& d: directions)  // Range-based for-loop MIGHT give faster performance 
    if (d.canFace (guy, xChoice, yChoice, zChoice))  
        break;  // (xChoice, yChoice, zChoice) is the position of the girl he wants to dance with