Fatal编程技术网
  • cplusplus/
  • C++ 似乎找不到无限循环的原因

C++ 似乎找不到无限循环的原因

c++ sorting loops

C++ 似乎找不到无限循环的原因,c++,sorting,loops,infinite-loop,C++,Sorting,Loops,Infinite Loop,我正在写一个计划，帮助一所四年制大学理清课程。由于某种原因，我陷入了while循环 /* some info: "course" is a class i created some of the member function are: bool fall() // does the class run in the fall? bool spring() // does the class run in the spring?

我正在写一个计划，帮助一所四年制大学理清课程。由于某种原因，我陷入了while循环

/*
some info:
"course" is a class i created
   some of the member function are:
      bool fall()           // does the class run in the fall?
      bool spring()         // does the class run in the spring?
      string name()         // name of this course
      ...                   // plenty of irrelevant stuff


"classes" is a vector of courses
"vector <vector <course> > out" has n (generally 8) elements

"vector <string> taken" records the names of the courses that have been taken

bool prereq_taken(course C, vector <string> & taken) checks if all the 
prerequisites of the course are taken

even semesters are fall and odd are spring

*/


int x = 0, semester = 0;
while ((classes.size() > 0)){
    x %= classes.size();

if (prereq_taken(classes[x], taken)){                                            // checks if all of the prerequisites in the course have already been taken

    // my test condition
    //if ((semester % 2 == 0) && classes[x].fall() && (!classes[x].spring())){

    // Ben's condtion
    if ((semester & 1)? classes[x].spring(): classes[x].fall()){

    // my retardedly long all-in-one condition
    /*if (
        (((!(semester % 2)) && classes[x].fall() && (!classes[x].spring()))    // if fall and is only fall class or
        || ((semester % 2) && (!classes[x].fall()) && classes[x].spring())     // if spring and is only spring class
        || (classes[x].fall() && classes[x].spring())                          // if any semester class

        )                                                                      // and there is class space and enough credit space
        && (((out[semester].size() + 1) < classes_per_semester) && ((credits[semester] + classes[x].credits()) < credits_per_semester))) {
    */
        taken.push_back(classes[x].name());                                      // put class name into vector of takens
        out[semester].push_back(classes[x]);                                     // put class into final output
        classes.erase(classes.begin() + x);                                      // remove from class list
    }
    else
        x++;

 }
    else
        x++;                                                                         // else go to next class

    if ((out[semester].size() + 1) > classes_per_semester)
        semester++;
}

/*
一些信息：
“课程”是我创建的一个类
一些成员函数包括：
bool fall（）//该类是否在秋季运行？
bool spring（）//该类是否在spring中运行？
string name（）//此课程的名称
...                   // 很多无关的东西
“班级”是课程的载体
“矢量输出”有n个（通常为8个）元素
“已修课程”记录已修课程的名称
bool prereq_take（课程C、向量和take）检查所有
这门课程的先决条件是
偶数学期是秋天，偶数学期是春天
*/
int x=0，学期=0；
而（（classes.size（）>0））{
x%=classes.size（）；
if（prereq_take（classes[x]，take））{//检查课程中的所有先修课程是否都已完成
//我的测试条件
//如果（（学期%2==0）&&classes[x].fall（）&&（！classes[x].spring（））{
//本氏条件
如果（（学期&1）？班级[x].spring（）：班级[x].fall（））{
//我那迟钝的长时间一体机状态
/*如果(
（（！（学期%2））&&classes[x].fall（）&&（！classes[x].spring（））//如果fall and是唯一的fall类或
||（（第%2学期）&&（！classes[x].fall（））&&classes[x].spring（）//如果spring和是唯一的spring类
||（课程[x].fall（）&&classes[x].spring（）//如果有学期课程
)//并且有类空间和足够的信用空间
&&（（（外[学期].size（）+1）<每学期课程数）和&（（学分[学期]+每学期课程数[x].credits（））<每学期学分数）））{
*/
take.push_back（类[x].name（））；//将类名放入takens的向量中
out[学期]。推回（类[x]）；//将类放入最终输出
class.erase（classes.begin（）+x）；//从类列表中删除
}
其他的
x++；
}
其他的
x++；//否则转到下一节课
如果（（外[学期].size（）+1）>每学期的课程）
学期++；
}
我正在尝试运行所有的数据（并循环），直到所有的课程都被正确放置

由于某种原因，当我在IF语句中加上星形，它循环永远存在。然而，如果没有它和<代码> EX/code >（但是内部代码仍然在代码中），代码将完成。为什么？C++布尔数学与Python的（与这个代码有关）有点不同？

如果我有任何含糊不清的地方，请告诉我要澄清什么。一个
&
本身就是一个按位and。你想要一个
&
。if语句中的那部分可能永远也达不到，所以大小不会改变。

一个
&
本身就是一个按位and。你想要一个
&
。if语句中的那部分是可能永远也达不到，所以大小不会改变。

你认为这有什么作用

if ((x == classes.size()))
    x %= classes.size();
任务与以下内容相同：

   x = x % classes.size();
但是您刚刚发现
x==classes.size（）

   x = classes.size() % classes.size();
对于任何
N
，
N%N
为零，这意味着

if ((x == classes.size()))
    x = 0;
这就是你想要的吗

所讨论的
if
只能处理秋季提供的课程。也许您想要：

if ((semester & 1)? classes[x].spring(): classes[x].fall()) { ... }
也许这样行吗

int x = 0, semester = 0, scheduled = 0;
vector<string> completed;
while ((classes.size() > 0)) {
    if (classes.size() == x) {
        x = 0;
        cout << "Checked all classes and scheduled " << scheduled << endl;
        if (0 == scheduled) {
            ++semester;
            completed = taken;
        }
        scheduled = 0;
    }

    if (prereq_taken(classes[x], completed)) {
        if ((semester & 1)? classes[x].spring(): classes[x].fall()) {
            if (credits[semester] + classes[x].credits() <= credits_per_semester) {
                taken.push_back(classes[x].name());
                out[semester].push_back(classes[x]);
                credits[semester] += classes[x].credits();
                cout << classes[x].name() << " will be taken in semester " << semester << " for " << classes[x].credits() << " credits" << endl;
                classes.erase(classes.begin() + x);
                scheduled++;
            }
            else {
               cout << classes[x].name() << " can't be taken in semester " << semester << " : overload on credits" << endl;
               x++;
            }
        }
        else {
            cout << classes[x].name() << " can't be taken in semester " << semester << " : not offered" << endl;
            x++;
        }    
     }
     else {
        cout << classes[x].name() << " can't be taken in semester " << semester << " : not offered" << endl;
        x++;                                                                         // 
     }

     if (out[semester].size() >= classes_per_semester || credits[semester] >= credits_per_semester) {
        cout << "Full load reached for semester " << semester << endl;
        semester++;
        completed = taken;
     }
}

intx=0，学期=0，计划=0；
向量完成；
而（（classes.size（）>0））{
if（classes.size（）==x）{
x=0；

你认为这有什么用


if ((x == classes.size()))
    x %= classes.size();


任务与以下内容相同：


   x = x % classes.size();


但是您刚刚发现
x==classes.size（）


   x = classes.size() % classes.size();


对于任何
N
，
N%N
为零，这意味着


if ((x == classes.size()))
    x = 0;


这就是你想要的吗



所讨论的
if
只能处理秋季提供的课程。也许您想要：


if ((semester & 1)? classes[x].spring(): classes[x].fall()) { ... }




也许这样行吗


int x = 0, semester = 0, scheduled = 0;
vector<string> completed;
while ((classes.size() > 0)) {
    if (classes.size() == x) {
        x = 0;
        cout << "Checked all classes and scheduled " << scheduled << endl;
        if (0 == scheduled) {
            ++semester;
            completed = taken;
        }
        scheduled = 0;
    }

    if (prereq_taken(classes[x], completed)) {
        if ((semester & 1)? classes[x].spring(): classes[x].fall()) {
            if (credits[semester] + classes[x].credits() <= credits_per_semester) {
                taken.push_back(classes[x].name());
                out[semester].push_back(classes[x]);
                credits[semester] += classes[x].credits();
                cout << classes[x].name() << " will be taken in semester " << semester << " for " << classes[x].credits() << " credits" << endl;
                classes.erase(classes.begin() + x);
                scheduled++;
            }
            else {
               cout << classes[x].name() << " can't be taken in semester " << semester << " : overload on credits" << endl;
               x++;
            }
        }
        else {
            cout << classes[x].name() << " can't be taken in semester " << semester << " : not offered" << endl;
            x++;
        }    
     }
     else {
        cout << classes[x].name() << " can't be taken in semester " << semester << " : not offered" << endl;
        x++;                                                                         // 
     }

     if (out[semester].size() >= classes_per_semester || credits[semester] >= credits_per_semester) {
        cout << "Full load reached for semester " << semester << endl;
        semester++;
        completed = taken;
     }
}



intx=0，学期=0，计划=0；
向量完成；
而（（classes.size（）>0））{
if（classes.size（）==x）{
x=0；

我认为问题在于你永远无法满足所有课程的要求。星号代码


if ((semester % 2 == 0) && classes[x].fall() && (!classes[x].spring())){


仅允许您参加秋季课程。如果必修课程仅在春季提供，您的代码将尝试分配课程，但由于缺少要求，无法添加新课程

现在，假设您修复了
，如果
，并允许满足课程要求。您仍然会依赖于数据是否正确（即没有周期性的课程相关性）。如果您不熟悉，我建议您继续阅读。一个简单的（尽管效率低下）处理无限循环可能性的方法是使用观察，在整个课程列表的每一步中，应该至少有一门课程从列表中删除。因此，您可以编写如下内容：


int x = 0, semester = 0, prev_size = classes.size();
while ((classes.size() > 0)){
    if (x == classes.size()){
        x = 0;
        if( classes.size() == prev_size ) { // no courses removed in the last cycle
            // signal error
            break;
        }
        else
            prev_size = classes.size();
    }
    ...
}



我认为问题在于你永远无法满足所有课程的要求。星号代码


if ((semester % 2 == 0) && classes[x].fall() && (!classes[x].spring())){


仅允许您参加秋季课程。如果必修课程仅在春季提供，您的代码将尝试分配课程，但由于缺少要求，无法添加新课程

现在，假设您修复了
，如果
，并允许满足课程要求。您仍然会依赖于数据是否正确（即没有周期性的课程相关性）。如果您不熟悉，我建议您继续阅读。一个简单的（尽管效率低下）处理无限循环可能性的方法是使用在每一步t