How can text in my main C++ file (in code that hasn't executed yet) show up in a string?

I'm new to C++ so there's a lot I don't really understand, I'm trying to narrow down how I'm getting exc_bad_access but my attempts to print out values seems to be aggravating (or causing) the problem!

#include <iostream>
#include "SI_Term.h"
#include "LoadPrefabs.h"

int main() {
    SI_Term * velocity = new SI_Term(1, "m/s");
    std::cout<<"MAIN: FIRST UNITS "<<std::endl;
    velocity->unitSet()->displayUnits();
    return 0;
}

The above code produces an error (EXC_BAD_ACCESS) before the std::cout<< line even occurs. I traced it with xcode and it fails within the function call to new SI_Term(1, "m/s").

Re-running with the cout line commented out it runs and finishes. I would attach more code but I have a lot and I don't know what is relevant to this line seeming to sneak backwards and overwrite a pointer. Can anyone help me with where to look or how to debug this?

NEW INFO: I narrowed it down to this block. I should explain at this point, this block is attempting to decompose a set of physical units written in the format kg*m/s^2 and break it down into kg, m, divide by s * s. Once something is broken down it uses LoadUnits(const char*) to read from a file. I am assuming (correctly at this point) that no string of units will contain anywhere near my limit of 40 characters.

UnitSet * decomposeUnits(const char* setOfUnits){
    std::cout<<"Decomposing Units";
    int i = 0;
    bool divide = false;

    UnitSet * nextUnit = 0;
    UnitSet * temp = 0;
    UnitSet * resultingUnit = new UnitSet(0, 0, 0, 1);

    while (setOfUnits[i] != '\0') {
        int j = 0;
        char decomposedUnit[40];
        std::cout<<"Wiped unit."<<std::endl;
        whil开发者_如何学Goe ((setOfUnits[i] != '\0') && (setOfUnits[i] != '*') && (setOfUnits[i] != '/') && (setOfUnits[i] != '^')) {
            std::cout<<"Adding: " << decomposedUnit[i]<<std::endl;
            decomposedUnit[j] = setOfUnits[i];
            ++i;
            ++j;
        }
        decomposedUnit[j] = '\0';
        nextUnit = LoadUnits(decomposedUnit);
        //The new unit has been loaded. now check for powers, if there is one read it, and apply it to the new unit.

        //if there is a power, read the power, read the sign of the power and flip divide = !divide
        if (setOfUnits[i] == '^') {
            //there is a power. Analize.
            ++i;++j;
            double power = atof(&setOfUnits[i]);
            temp = *nextUnit^power;
            delete nextUnit;
            nextUnit = temp;
            temp = 0;
        }
            //skip i and j till the next / or * symbol.
        while (setOfUnits[i] != '\0' && setOfUnits[i] != '*' && setOfUnits[i] != '/') {
            ++i; ++j;
        }

        temp = resultingUnit;

        if (divide) {
            resultingUnit = *temp / *nextUnit;
        } else {
            resultingUnit = *temp * *nextUnit;
        }
        delete temp;
        delete nextUnit;
        temp = 0;
        nextUnit = 0;

        // we just copied a word and setOfUnits[i] is the multiply or divide or power character for the next set.
        if (setOfUnits[i] == '/') {
            divide = true;
        }

        ++i;

    }
    return resultingUnit;
}

I'm tempted to say that SI_Term is messing with the stack (or maybe trashing the heap). Here's a great way to do that:

char buffer[16];
strcpy(buffer, "I'm writing too much into a buffer");

Your function will probably finish, but then wreak havoc. Check all arrays you have on the stack and make sure you don't write out of bounds.

Then apply standard debugging practices: Remove code one by one until it doesn't crash anymore, then start reinstating it to find your culprit.

You are mentioning xcode, so I assume you're on a MAC. I'D then suggest looking at the valgrind tool from http://valgrind.org/ That's a memory checker giving you information when yo're doing something wrong with memory. If your program was build including debugging symbols it should give you an stacktrace helping you to find the error.

Here, I removed the unimportant stuff:

while (setOfUnits[i] != '\0') {
    while ((setOfUnits[i] != '\0') && (setOfUnits[i] != '*') && (setOfUnits[i] != '/') && (setOfUnits[i] != '^')) {
        ...
        ++i;
    }

    ...
    nextUnit = LoadUnits(decomposedUnit);

    ...
    if (...) {
        double power = ...;
        temp = *nextUnit^power;
        delete nextUnit;
    }

    ....
    temp = resultingUnit;
    delete temp;
    delete nextUnit;

    ...
    ++i;
}

There are a number of problems with this:

• In the inner-loop, you increment i until setOfUnits[i] == '\0', the end of the string. Then you increment i again, past the end of the string.
• nextUnit is of type UnitSet, which presumably overloads ^. Though it's possible that it overloads it to mean "exponentiation", it probably doesn't (and if it does, it shouldn't): in C-based languages, including C++, ^ means XOR, not exponentiation.

• You are deleting pointers returned from other functions - that is, you have functions that return dynamically-allocated memory, and expect the caller to delete that memory. While not incorrect, and in fact common practice in C, it is considered bad practice in C++. Just have LoadUnits() return a UnitSet (rather than a UnitSet*), and make sure to overload the copy constructor and operator= in the UnitSet class. If performance then becomes a concern, you could return a const UnitSet& instead, or use smart pointers.
  In similar vein, you are allocating and deleting inside the same function. There is no need for this: just make resultingUnit stack-allocated:

  UnitSet resultingUnit(0, 0, 0, 1);
  

I know that last bullet-point sounds very confusing, but once you finally come to understand it, you'll likely know more about C++ than 90% of coders who claim to "know" C++. This site and this book are good places to start learning.

Good luck!