Getting heap corruption when writing to a file - c++

Question

Im trying to write a powerset to a file, but I get a heap corruption if my starting array is bigger than size 6, and im not sure why. It works fine with any size of array 6 or under. Cant figure this out.
Also, test.txt is where I read in the array. If the file contains"1,2,3,4,5,6" it works fine, but it it contains "1,2,3,4,5,6,7" I get heap corruption.
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
#include "N26.h"
#include <math.h>
using namespace std;
void increaseArray(int* theArray, int size)
{
int i = size;
int n = i+1;
int* newArray = new int[n];
for(int cnt=0;cnt<n;cnt++)
{
newArray[cnt] = theArray[cnt];
}
newArray[n-1]= NULL;
theArray = newArray;
return;
}
void printPowerSet(int *s, int n)
{
int i=0,j=0;
ofstream myFile;
double SetSize=pow(2.0,n);
myFile.open("powerset1.txt", std::ios_base::app);
cout<<"{size of original}"<< n <<endl;
cout<<"{number of sets}"<< SetSize-1 <<endl;
for(i=1;i<SetSize;++i)
{
for(j=0;j<n;++j)
{
if(((i>>j)&1)==1)
{
myFile << s[j] <<",";
}
}
myFile<<endl;
}
return;
}
int main()
{
ifstream myFile;
int item;
string input ="";
string fileName = "test.txt";
myFile.open(fileName);
while(myFile)
{
int k = 1;
int* transaction= new int[1];
if(!getline(myFile,input))
break;
istringstream ss(input);
while(ss)
{
if(!getline(ss,input, ','))
break;
input.erase(remove_if(input.begin(), input.end(), isspace), input.end());
item = atoi(input.c_str());
transaction[k-1] = item;
increaseArray(transaction,k);
k++;
}
for(int i =0; i<k-1;i++)
{
cout << transaction[i];
}
printPowerSet(transaction, k-1);
cout << endl;
transaction=NULL;
}
system("Pause");
return 0;
}

Answer 1

Your increaseArray() function doesn't work because you're only changing a local copy of the pointer. You'd have to pass a double pointer or a pointer reference to do what you want.
Example of a reference to pointer:
void increaseArray(int*& theArray, int size)
Instead, I'd recommend using a std::vector, since this will grow automatically.
I doubt this has any bearing on your problem, but I don't see that you ever delete, either. You are leaking memory. Before reassigning your pointer with a new allocation, delete the old allocation:
delete [] theArray; // The "[]" is important!
theArray = newArray;

Answer 2

In addition to Fred's answer.
Look at what's going on inside increaseArray(), specifically these lines:
int i = size;
int n = i+1;
int* newArray = new int[n];
for(int cnt=0;cnt<n;cnt++)
{
newArray[cnt] = theArray[cnt];
}
You allocate an array of size + 1 elements, and then iterate over the original. That's off-by-one, i.e. you are accessing one element outside of the original array. That might get you a segmentation fault depending on how new lays out the heap, but sure is undefined behavior.