why am i getting a segmentation fault in my output?

[nar0122]

//Nicholas Riseden
//CSCI 3300
//Assignment 4 Version 2
 
#include "tree.h"
#include "pqueue.h"
#include <string>
#include <fstream>
#include <iostream>
#include <stdio.h>
#include "binary1.h"
 
using namespace std;
 
/*****************************************************************
*                            buildTree                           *
******************************************************************
* buildTree takes the array built from getFrequency and builds a *
* tree that holds a character and its priority using the insert  *
* function.                                                      *
*                                                                *
* For example, if the file reads "AAb" it creates a node for the *
* character 'A' and stores its priority 2 for that node.         *
*****************************************************************/
Node* buildTree(int arrayOfInts[])
{
    PriorityQueue q;
    for(int x = 0; x <= 255; x++)
    {
        if(arrayOfInts[x]!=0)
        {            
            Node* leaf = new Node((char)x);
            insert(q, leaf, arrayOfInts[x]);
        }
    }
 
    Node* t1,*t2;
    int p1, p2;
    remove(q, t1, p1);
 
    while(isEmpty(q)==false)
    {
        remove(q,t2, p2);
        Node* t3 = new Node(t1, t2);
        insert(q, t3, (p1 +p2));
        remove(q, t1, p1);
    }
 
    return t1;
}
 
/*****************************************************************
*                            getFrequency                        *
******************************************************************
* getFrequency takes an array of 256 integers.  It opens a       *
* file and counts the amount of character                        *
* frequencies that occur, storing that count into the position   *
* in the array that correpsonds with the character's             *
* Ascii value.                                                   *
*                                                                *
* For example, if the file reads "AAb" it stores the number 2 in *
* position 64 in the array since capital A is a 65 on the Ascii  *
* chart and arrays are zero based.                               *
*****************************************************************/
 
int* getFrequency(char* filename, int arrayOfInts[])
{
    ifstream in;
    in.open(filename);
    for(int i = 0; i < 256; i++)
    {
        arrayOfInts[i] = 0;
    }
 
 
 
    int c = in.get();
 
    while(c!=EOF)
    {
        arrayOfInts[c]++;
        c = in.get();
    }
 
    int count = 0;
    cout<<"\nThe character frequencies are: \n\n";
    int k = 0;
    while(k < 256)
    {
 
        if(k>0)
        {
 
            if(k == 10)
            {
                cout<<"\\n "<<arrayOfInts[k]<<"\n";
            }
            else if(k!=10)
            {
            cout<<char(k)<< " "<<arrayOfInts[k]<<"\n";
            }
        }
 
 
    count++;
    cout<<"count is "<<count<<"\n";//count reaches 256, then segmentation fault is printed
    k++;
    }
 
    in.close();
    cout<<"This is sparta\n";
    return arrayOfInts;
    cout<< "This is over\n";
 
}
 
//comments to describe this function
void writeTree(BFILE* f, Node* t)
{  
        if(t->kind!=leaf)
        {
            writeBit(f, 0);
            writeTree(f, t->left);
            writeTree(f, t->right);
        }
        else
        {
            writeBit(f, 1);
            writeByte(f, t->ch);
        }
 
 
}
//buildcode
void buildCode(Node* n, string codeArray[], string pref)
{
    if(n->kind == leaf)
    {    
        codeArray[int(n->ch)] = pref;
    }
    else if(n->kind == nonleaf)
    {
        buildCode(n->left, codeArray, pref + "0");
        buildCode(n->right, codeArray, pref + "1");
    }
 
}
//writecode(f, str) writes string str to BFILE* f, one bit
//at a time.
void writeCode(BFILE* f, string str)
{
        int y = str.length();
        for(int x = 0; x < y; x++)
        {
            writeBit(f, str[x]);
        }
 
}
 
//function description
void writeCodedFile(char* filename, string codearray[], BFILE* f)
{
    ifstream in;
    in.open(filename);
        int c = cin.get();
        while(c != EOF)
        {
            writeCode(f, codearray[c]);
            c = cin.get();
        }
cout<<"Test E";
    in.close();
}
 
 
int main(int argc, char* argv[])
{
        string codeArray[255];
    int arrayOfInts[255];
    int* frequencyArray = getFrequency(argv[1], arrayOfInts);//problem is here
    cout<<"I am about to do buildTree.";//this never gets printed
    Node* n = buildTree(frequencyArray);
    cout<<"I am done buildTree.";//this never gets printed
    buildCode(n, codeArray, "");
 
    BFILE* f = openBinaryFileWrite(argv[2]);
 
    writeTree(f,n);
 
    writeCodedFile(argv[1], codeArray,f);
 
    closeBinaryFileWrite(f);
 
    return 0;
 
}

[anhpnt]

Could you debug this and show me the line where the program stopped?

[nar0122]

Yes, will do it now.

[nar0122]

This is my current code
See attached for output
It is doing exactly what I want, just printing the segmentation fault at the end. It is not getting to any other functions before or after it because of the segmentation fault

 
/*****************************************************************
*                            getFrequency                        *
******************************************************************
* getFrequency takes an array of 256 integers.  It opens a       *
* file and counts the amount of character                        *
* frequencies that occur, storing that count into the position   *
* in the array that correpsonds with the character's             *
* Ascii value.                                                   *
*                                                                *
* For example, if the file reads "AAb" it stores the number 2 in *
* position 64 in the array since capital A is a 65 on the Ascii  *
* chart and arrays are zero based.                               *
*****************************************************************/
 
int* getFrequency(char* filename, int arrayOfInts[])
{
    ifstream in;
    in.open(filename);
    for(int i = 0; i <= 256; i++)
    {
        arrayOfInts[i] = 0;
    }
 
    int c = in.get();    
    while(c!=EOF)
    {        
            arrayOfInts[c]++;
            c = in.get();
    }
 
    cout<<"\nThe character frequencies are: \n\n";
    for(int count = 0; count<=256; count++)
    {
        while(arrayOfInts[count]!=0)
        {
            if(count == 10)
            {
                cout<<"\\n "<<arrayOfInts[count]<<"\n";
                count++;
            }
            else 
            {
                cout<<char(count)<< " "<<arrayOfInts[count]<<"\n";
                count++;
            }
        }
 
    }
 
    in.close();
 
    return arrayOfInts;
 
 
}

[anhpnt]

The image is too small to see. Actually, even if i can see it clearly, i can't tell you what the error is, because there is not enough information.
According to your code, i saw that the upper bound of loop is 256, while the array size is 256. Correct it to 255.
Also, change the print loop as the following code, run it and show me last output lines (3 lines at most).

cout<<"\nThe character frequencies are: \n\n";
for(int count = 0; count<=255; count++)
{
cout << count << " ";
if (count == 10)
    cout << "\\n ";
else
    cout << char(count) << " ";
 
cout << arrayOfInts[count]<<"\n";
}
 

[nar0122]

The last three lines are as follows:

254 \ufffd 0
255 \ufffd 0
Segmentation fault
nar0122@tecs-cs-sshpol3:~/Desktop/3300/assn4/programOne>

[anhpnt]

I have run your code successfully, and the output is different from yours.
I guess the error is somewhere outside this function.
Also, could you send me you input file?
You should use debugging tools to find the error more easily.

[Frinavale]

I see what you're doing now.
You're trying to do too much with one variable.

You need one variable to keep track of how many times you have iterated through the array (how many times you've looped).

You should be using another variable to print the number of characters found in the array at that iteration.

If there is 0 for a specific character then don't do anything ...just loop to the next index.

This is a much cleaner approach that I hope will fix your problem.

int* getFrequency(char* filename, int arrayOfInts[])
{  
    ifstream in;
    for(int i = 0; i < 256; i++)
    {
        arrayOfInts[i] = 0;
    }  
 
    in.open(filename);
    int c = in.get();    
     while(c!=EOF)
    {
        if(c>0 && c<256)
        {
            arrayOfInts[c]++;
        }
        c = in.get();
    }
    in.close();
 
    cout<<"\nThe character frequencies are: \n\n";
    int numberOfCharacters = 0;
    for(int i = 0; i<256; i++)
    {   numberOfCharacters = arrayOfInts[i];
        if(i==10}
        {   cout << "\\n ";}
        if(numberOfCharacters > 0)
        {
                cout<<char(i)<< " "<<numberOfCharacters<<"\n";
        }
    }
 
    return arrayOfInts;  
}

-Frinny

PS. Could you please post code snippets in code tags.

[nar0122]

I did not get the segmentation fault after modifying my program; however, I got some pretty crazy errors. I think it is saying I have a memory leak somewhere.

Does this mean anything to anyone?

*** glibc detected *** ./huffman: free(): invalid pointer: 0x00007fffd5592 6f8 ***

[Frinavale]

Nar0122, does that mean your original problem is fixed?
If so, please start a new thread for your new problem and indicate which post helped you to solve the problem you needed help with in this thread.

-Frinny