c++ - C++中的左大括号 "{"错误

Question

我在尝试编译我创建的模板类时遇到“在匹配左大括号之前文件结束”。当我双击 Visual Studio 中的错误消息时，它会将我带到我尝试运行代码的“主”文件的顶部。当我转到该类的 .cpp 文件时，所有成员函数都被最小化，除了一个......这让我觉得这就是问题所在？有没有一种快速的方法可以找到丢失的支架在哪里？

我认为它存在于这个特定成员函数中的另一个原因是在声明的底部，因为我添加了右大括号(我从缩进为 5 个空格的代码块中添加它们)，通常当您键入一个并按下回车键、键入一个并按下回车键等时，Visual Studio 会将它们置于正确的缩进位置，但在这种情况下，它会停止缩进大约两个“制表符”，而只会在我继续时将它们置于相同的缩进位置键入“}”并按回车键，键入“}”并按回车键...

成员函数的代码又复杂又长，很难看完，虽然我看了大概5遍，也找不到哪里漏了。这有什么诀窍吗？我能找对地方吗？谢谢!

编辑:

我没有发布它是因为，老实说，它太丑了。我正在实现我的第一个真正的类，它是一个模板类——数组的链表。它太长太乱了，我可能应该在里面有一些更好的抽象。除了一点 self 意识之外，我还认为你们会看一眼帖子然后继续，我知道我很想...另外注意:我没有评论所有内容，因为大部分代码都是重复，只是在不同的初始条件下。

    template <typename Type>
    void PQueue<Type>::enqueue(Type element)
    {
        blockT *runner = listHead; //BE CAREFUL - duplicate so as not to eff with listHead - used deep

        //case 1: if this is the first element entered
        if (listHead == NULL) {
            blockT *newBlock = new blockT;
            newBlock->blockTArray = new Type[MaxElementsPerBlock];
            newBlock->capacity = MaxElementsPerBlock;
            newBlock->next = NULL;
            newBlock->head = 0;
            newBlock->blockTArray[0] = element;
            newBlock->tail = 1;
            listHead = newBlock;
        }

        //case 2: element > blockTArray[0]
        else if (element >= runner->blockTArray[0]) { 
            //CASE 2A
            if (runner->tail < runner->capacity) {
                for (int i = runner->tail; i > 0; i--) { //iterate through array
                    runner->blockTArray[i] = runner->blockTArray[i-1]; //move everything 1 to right
                }
                runner->blockTArray[0] = element; //insert "element" at front
                runner->tail++; //increment tail
            }
            //CASE 2B
            else {
                blockT *newBlock = new blockT;
                newBlock->next = runner;
                newBlock->blockTArray = new Type[MaxElementsPerBlock];
                newBlock->blockTArray[0] = element;
                newBlock->tail = 1;
                newBlock->head = 0;
                newBlock->capacity = MaxElementsPerBlock;
                listHead = newBlock;
            }
        }

        //case 3: if runner is less than runner array[head] and array is NOT full
        else if (element < runner->blockTArray[0]) {
            //TRAVERSE TO FIND END OR BLOCKTARR > ELEMENT
            blockT *back;
            while (true) {
                if (runner->next == NULL || runner->blockTArray[0] <= element) break;
                else {
                    back = runner;
                    runner = runner->next;
                }
            }

            //EQUAL TO ELEMENT
            if (runner->blockTArray[0] == element) {
                //INSERT ON THAT ARR IF SPACE
                if (runner->tail < runner->capacity) {
                    for (int i = runner->tail; i > 0; i--) { //iterate through array
                        runner->blockTArray[i] = runner->blockTArray[i-1]; //move 1 right
                    }
                    runner->blockTArray[0] = element; //insert "element" at front
                    runner->tail++;
                }
                //ELSE MAKE NEW BLOCK AND PUT 1/2 ELEMENTS ON IT
                else {
                    blockT *newBlock = new blockT;
                    newBlock->blockTArray = new Type[MaxElementsPerBlock];
                    newBlock->capacity = MaxElementsPerBlock;
                    newBlock->blockTArray[0] = element;
                    newBlock->tail = 1;
                    newBlock->head = 0;
                    newBlock->next = runner; //set this new block's "next" = to cell runner was  pointing at
                    back->next = newBlock; //take the cell the runner was stored in (back->next) and set it to new block's address
                }
            }
            //if we stopped because the next arr[0] is smaller, use ->back to place on previous cell 
            else if (runner->blockTArray[0] < element) {
                //if element is bigger than or equal to current arr and -> isn't full, add to front of ->
                if (element == back->blockTArray[back->tail - 1] && runner->tail < runner->capacity) {
                    for (int i = runner->tail; i > 0; i--) { //iterate through array
                        runner->blockTArray[i] = runner->blockTArray[i-1]; //move everything 1 to right
                    }
                    runner->blockTArray[0] = element; //insert "element" at front
                    runner->tail++;
                }

                else if (element == back->blockTArray[back->tail - 1] && runner->tail == runner->capacity) {
                    if (back->tail == back->capacity) {
                        blockT *newBlock = new blockT;
                        newBlock->blockTArray = new Type[MaxElementsPerBlock];
                        newBlock->capacity = MaxElementsPerBlock;
                        newBlock->blockTArray[0] = element;
                        newBlock->tail = 1;
                        newBlock->head = 0;
                        newBlock->next = runner; //set this new block's "next" = to cell runner was pointing at
                        back->next = newBlock;
                    }
                    else {
                        for (int i = 0, i < back->tail; i++) {
                            if (element <= back->blockTArray[i]) {
                                for (int x = runner->tail; x >= i; x--) { //iterate through array
                                    runner->blockTArray[x] = runner->blockTArray[x-1]; //move everything 1 to right
                                }
                                runner->blockTArray[i] = element; //insert "element" at front
                            }
                        }
                    }
                }
                else if (back->tail == back->capacity) {
                    for (int i = 0, i < back->tail; i++) {
                        if (element <= back->blockTArray[i]) {
                            blockT *newBlock = new blockT;
                            newBlock->blockTArray = new Type[MaxElementsPerBlock];
                            newBlock->capacity = MaxElementsPerBlock;
                            newBlock->head = 0;
                            for (int x = (MaxElementsPerBlock - (i+3)), z = runner->tail;
                                x >= 0, z > i; x--, z--) {
                                newblock->blockTArray[x] = runner->blockTArray[z - 1];
                            }
                            runner->blockTArray[i + 1] = element;
                            runner->tail = i + 2; //you're two ahead in this case since you wrote to i+1
                            newBlock->tail = i + 1; //because you're one ahead of the element you inserted 
                            back->next = newBlock;
                            newBlock->next = runner;
                            break;
                        }
                    }
                }
            }
            //NULL CASE if next is null but current arr isn't full, shuffle and insert here
            else if (runner->next == NULL && runner->tail < runner->capacity) {
                for (int i = 0; i < runner->tail; i++) {
                    if (element <= runner->blockTArray[i]) {
                        for (int x = runner->tail - 1; x > blockTArray[i]; x--) {
                            runner->blockTArray[x + 1] = runner->blockTArray[x];
                        }
                        runner->tail++;
                    }
                }
            }
            else if (runner->next == NULL && runner->tail == runner->capacity) {
                for (int i = 0, i < back->tail; i++) {
                    if (element <= runner->blockTArray[i]) {
                        blockT *newBlock = new blockT;
                        newBlock->blockTArray = new Type[MaxElementsPerBlock];
                        newBlock->capacity = MaxElementsPerBlock;
                        newBlock->head = 0;
                        for (int x = (MaxElementsPerBlock - (i+3)), z = runner->tail;
                            x >= 0, z > i; x--, z--) {
                            newblock->blockTArray[x] = runner->blockTArray[z - 1];
                        }
                        runner->blockTArray[i + 1] = element;
                        runner->tail = i + 2; //you're two ahead in this case since you wrote to i+1
                        newBlock->tail = i + 1; //because you're one ahead of the element you inserted 
                        runner->next = newBlock;
                        newBlock->next = NULL;
                        break;
                    }
                }
            }
            }

你可以在末尾看到双 } }。信不信由你，我花了一些时间来思考并编写这段代码。我希望它更干净、更专业，但我不确定最好的方法。抽象？除了库存的 Visual Studio，你们还使用任何东西吗？有安装环境吗？我刚刚看到一篇关于“Artistic Style 2.02”的帖子。值得吗？谢谢你让你的眼睛看到这个......

Answer 1

如果您完全不知道编译后发生了什么变化，请通过以下方式禁用大部分源代码

#if 0

#endif

围绕代码。测试编译以确保错误消失。如果是，请减少被注释掉的代码量，然后重试。它应该是一个相当快的二分搜索(对于一个大模块 5-10 次迭代)来识别有问题的大括号。