Question

It works with Visual Studio, but segfaults in Cygwin, which is weird because I’m compiling the same source, and both generate a Windows executable. GDB doesn’t work very well for me in Cygwin for some reason, and the error doesn’t appear in VS so I can’t really debug it there.

Any ideas?

int main(void)
{
    Pair ***occurences = new Pair**[20];

    int i, j, k;
    for (i = 0; i < 20; i++)
    {
        occurences[i] = new Pair*[i+1];

        for (j = 0; j < i+1; j++)
        {
            occurences[i][j] = new Pair[26];

            for (k = 0; k < 26; k++)
            {
                Pair pair;
                pair.c = k + 'a';
                pair.occurs = 0;
                occurences[i][j][k] = pair;
            }
        }
    }

    std::fstream sin;
    sin.open("dictionary.txt");
    std::string word;

    while (std::getline(sin, word))
    {
        if (word.size() < 21)
        {
            for (i = 0; i < word.size(); i++)
            {
                // SEGFAULTING HERE
                occurences[word.size()-1][i][word[i] - 'a'].occurences++;
            }
        }
    }

    for (i = 0; i < 20; i++)
    {
        for (j = 0; j < i+1; j++)
        {
            delete [] occurences[i][j];
        }
        delete [] occurences[i];
    }
    delete [] occurences;

    return 0;
}

Answer 1

You marked this line as the critical point:

occurences[word.size()-1][i][word[i] - 97].occurs++;

All three array accesses might go wrong here, and you would have to check them all:

It seems like the first dimension of the array has the length 20, so the valid values for the index are [0..19]. word.size()-1 will be less than 0 if the size of the word is zero itself, and it will be larger than 19 if the size of the word is 21 or more.

Are you sure the length of the word is always in the range [1..20]?

The second dimension has variable length, depending on the index of the first dimension. Are you sure this never gets out of bound?

The third dimension strikes me as the most obvious. You subtract 97 from the character code, and use the result as index into an array with 26 entries. This assumes that all characters are in the range of [97..122], meaning [‘a’..’z’]. Are you sure that there will never be other characters in the input? For example, if there are any capital characters, the resulting index will be negative.