I’m getting an “end of file before the left brace was matched” while trying to compile a template class that I created. When I double click on the error message in Visual Studio it takes me to the top of the “main” file where I’m trying to run the code. When I go to the .cpp file for the class, all the member functions are minimized except for one…which makes me think that’s where the problem is? Is there a quick way to find where missing brace is?
Another reason I think it exists in this one particular member function is that at the bottom of the declaration, as I’m adding closing braces (I’m adding them from a code block that is indented like 5 spaces), normally Visual Studio puts them at the correct indentation as you type one and push enter, type one and push enter, etc. but in this case it stops indenting about two “tab” over and will just keep putting them on the same indentation as I continue to type “}” and press enter, type “}” and press enter…
The code for the member function is complicated and long enough that it’s hard to go through and even though I have about 5 times, I can’t find where anything is missing. Is there a trick to this? Could I be looking in the right place? Thanks!
EDIT:
I didn’t post it because, to be honest, it’s ugly as hell. I’m implementing my first real class and it’s a template class – linked list of array’s. It’s waay too long and messy and I probably should have some better abstraction within. In addition to a little self conciousness, I also figured you guys would take one look at the post and move on, I know I’d be tempted to… Also NOTE: I didn’t comment everything because much of the code get’s repetitive, only under different initial conditions.
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;
}
}
}
}
You can see at end the double } }. Believe it or not it’s taken me a while to think through this and write this code. I’d like it to be cleaner, more professional, but I’m not sure the best ways to go about that. Abstraction? Do you guys use anything in addition to stock Visual Studio? Any installed environments? I just saw a post about the “Artistic Style 2.02.” Worthwhile? Thanks for subjecting your eyes to this…
If you have absolutely no idea what has changed since it compiled, disable most of the source code by placing
around the code. Test compile to make sure the error is gone. If it is, reduce the amount of code which is commented out and try again. It should be a fairly quick binary search (5-10 iterations for a large module) which identifies the offending brace.