Question

我可以一直假设......如果......

int main()
{
    ...
    foo1();
    foo2();
    foo3();
    ...
    return 0;
}

foo1（）总是在foo2（）之前，foo2（）总是在程序完成中的foo3（）之前（指最高的完成抽象）？

在我的实际程序中，foo2（）和foo3（）是否发生取决于foo1是否是一个非常“长”的函数，这意味着如果foo1（）中有一个巨大的for循环，那么到我完成并得到到程序结束时，foo2（）和foo3（）不会发生。在我的程序中foo1（） - foo3（）访问相同的地图。 f001（）初始化地图中的所有可用元素，foo2（），foo3（）然后用从文件读取的别名数据替换初始化。出现这种情况的原因是什么？

以下是2个函数，程序的其余部分是大而且偏离主题：

void loadDEADBEEF()
{
    for (long long i=0; i<=268435888; i+=4)//268435888
    {
            MainMemory[i] = 3735928559;
            HEXMainMemory[i] = "DEADBEEF";
    }
}

void LoadMemory(string str)//load hex dump into memory
{
    filecounter++;
    vector<int> V;//temperary vector
    vector<string> tempV;//temperary vector
    ifstream inClientFile( str.c_str(),ios::in ); //stream object
    vector<string> words;
    string word;
    int offset=0;
    if ( !inClientFile ) cerr << "File couldn't be opened" << endl;//test if instruction file can be opened
    //fill string vector with all file values and determines length of program
    while (inClientFile >> word)words.push_back(word);//capture raw code from file
    const int wordCount=words.size();//determine most efficient sizing for vectors
    tempV.reserve(wordCount);//size vector
    for(int i=0; i<wordCount; i++)
    {
        if (i==0 && words[i].length()==10) tempV.push_back(words[i]);//include first word to obtain data offset (memory insertion point)
        if (words[i].length()==8 
                && words[i].find(".")==string::npos )

            tempV.push_back(words[i]);//cut out undesired strings from vector
    }
    for( int y=2; y<10; y++) offset+=hexCharValue(tempV[0][y])<<(4*(9-y));//convert offset from hex to decimal
    tempV.erase(tempV.begin());//delete offset from vector
    V.resize(tempV.size());//resize vector
    for( int j=0; j<tempV.size(); j++ )//convert string hex to numerical decimal
    {

        for( int y=0; y<8; y++) V[j]+=hexCharValue(tempV[j][y])<<(4*(7-y));//4194608+4*
        if (load_memory) 
        {
            MainMemory.insert(mapType::value_type(4*j+offset,V[j]));//insert (location in memory,data)
            HEXMainMemory.insert(pair<int, string>(4*j+offset,tempV[j]));
        }    
    }
    if( filecounter == 1 ) PC_start = offset-4;
}

所以，第一个函数是“foo1（）”，第二个函数是“foo2（）”。主要是：

#include 
...
typedef map<int, int> mapType;//format of map: ( address, data )
typedef map<int, string> mapType2;//format of map: ( address, data )
mapType MainMemory;
mapType2 HEXMainMemory;
...
int main(int argc, char **argv)
{
    ...
    loadDEADBEEF();
    LoadMemory("hello_1.txt");//reginfo
    ...
    return 0;
}

Answer 1

假设你没有线程或任何东西，你总是可以假设foo1（）将在foo2（）之前发生，这也将发生在foo3（）之前。

您可以使用调试器或控制台对此进行验证。尝试将它放在每个fooX（）中：

std::out << "This is foo1()" << std::endl

Answer 2

当foo1（）有一个“大循环”时，你的程序是否完全退出？你可以发布代码吗？大循环案例可能会导致崩溃，因此foo2（）和foo3（）永远不会执行。

Answer 3

没有真正的代码很难帮助你。

使用“打印”输出来跟随您的代码（堰，但帮助）

如果你没有使用线程foo2 ..将会发生fooN，除了发生一些异常退出。检查这个使用print或其他东西来“追踪”程序所在的位置。

Answer 4

是的，它们将始终按此顺序出现。

小心发布代码的结果，以显示它是如何发生的？

Answer 5

foo2和foo3将始终发生，除非在其调用之前（例如foo1）导致程序退出（很可能是异常）。

Answer 6

如果未执行foo2()和foo3()，则foo1()可能会抛出异常，或以其他方式退出应用程序。作为调试步骤，您可以尝试在foo1()块中包装try...catch。

Answer 7

这是调试器可能有用的问题。我建议在战略位置放置断点，以确定在foo1完成后程序执行结束的位置。我的猜测是，由于调用exit或崩溃，程序在foo1中间退出。

程序存储器问题

7 个答案: