memory error after returning a class

[fredhenry]

Hi,
I have two different classes each in a separate header file and a .cpp file.
In the main function I create an instance of each class and then call a test function in one of the classes which should return an instance of the other class. The information in the returned class is stored using a custom operator= function.
When the program runs (with no build errors) I get an error from the console, "assertion failed" ... "line 52" ... "_BLOCK_TYPE_IS_VALID(phead->nblockuse)"
I don't know which line "line 52 refers to".

A google search makes me think the error is from trying to access memory which has already been deleted but I'm not actually sure which bit of the program is doing this
When line 17, "delete [] data;", from the fArray.h file is removed the error goes away.

Obviously I don't want to leave this out because I'd end up with a lot of useless memory, does anyone know what to do?

I can also comment out all the non-constructor/destructor functions in the fArray.h file and get the same result.

Thanks, Henry.

//.cpp////////////////////////////
#define _USE_MATH_DEFINES

#include <iostream>
//#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <cstdlib> 
//#include<ctime>
#include <string>
#include <fstream>
#include <sstream>
using namespace std;

#include "Vec2.h"
#include "Circle.h"
#include "fArray.h"

typedef unsigned short int usi;
typedef signed short int ssi;
typedef unsigned long int uli;
typedef signed long int sli;

int main(){
	Circle<int,int> test(2,1,1);
	fArray<int> test3;
	test3 = test.testFnc();
	//Circle<int,int> test2 = test3.testFnc();
	//circum = test.genCircum<long double>(8);
}
/////////////////////////////////////////////////////


relevent function is last
//circle.h///////////////////////////////////////////
#pragma once

#include "fArray.h"
#include "Vec2.h"
typedef unsigned short int usi;
typedef signed short int ssi;
typedef unsigned long int uli;
typedef signed long int sli;


template <class cType,class rType>
class Circle
{
	Vec2<cType> center;
	rType rad;
public:
	Circle(void){
		center.setV(0,0);
		rad = 0;
	}
	Circle(Vec2<cType> ncenter,rType nrad){
		center = ncenter;
		rad = nrad;
	}
	Circle(cType ncx,cType ncy,rType nrad){
		center.setV(ncx,ncy);
		rad = nrad;
	}
	void operator+= (Vec2<cType> pc){
		center += pc;
	}
	void operator+= (rType pr){
		rad += pr;
	}
	void operator-= (Vec2<cType> pc){
		center -= pc;
	}
	void operator-= (rType pr){
		rad -= pr;
	}
	void operator= (Vec2<cType> nc){
		center = nc;
	}
	void operator= (Circle<cType,rType> nc){
		center = nc.getCenter();
		rad = nc.getRad();
	}
	Vec2<cType> getCenter(){
		return center;
	}
	rType getRad(){
		return rad;
	}
	template <class nType>
	void convertC(){
		center.convert<nType>();
	}
	template <class nType>
	void convertR(){
		rad = (nType) rad;
	}
	template <class nType,class nType2>
	void convertCR(){
		convertC<nType1>();
		convertR<nType2>();
	}
	void coutC(){
		cout<<"Circle center: x = "<<center.getX()<<"\ty = "<<center.getY()<<"\tradius "<<rad<<endl;
	}
	template <class vType>
	fArray<Vec2<vType>> genCircum(usi split){
		fArray<Vec2<vType>> tempA;
		for(usi i = 0;i < split;i++){
			Vec2<vType> temp;
			//Vec2<cType> add;
			temp.setD(rad,360*i/split);
			//add = center;
			//add.convert<vType>();
			//temp += add;
			tempA.addEnd(temp);
		}
		return tempA;
	}
	fArray<int> testFnc(){
		fArray<int> temp;
		return temp;
	}
};
/////////////////////////////////////////////////////////////

//fArray.h////////////////////////////////////////////////
#pragma once

typedef signed long int sli;

template <class mType>
class fArray
{
	sli length;
	mType *tempData;
	mType *data;
public:
	fArray(void){
		length = 0;
		data = new mType[length];
	}
	~fArray(void){
		delete [] data;
	}
	mType getValue(sli i){
		return data[i];
	}
	void add(mType value,sli index){
		length++;
		tempData = new mType[length];
		for(sli i=0;i<index;i++){
			tempData[i] = data[i];
		}
		for(sli i=index;i<length-1;i++){
			tempData[i+1] = data[i];
		}
		tempData[index] = value;
		delete [] data;
		data = new mType[length];
		for(sli i = 0;i < length;i++){
			data[i] = tempData[i];
		}
		delete [] tempData;
	}
	void addEnd(mType value){
		add(value,length);
	}
	sli getLength(){
		return length;
	}
	void operator= (fArray<mType> na){
		delete [] data;
		length = na.getLength();
		data = new mType[length];
		for(sli i =0;i<length-10;i++){
			data[i] = na.getValue(i);
		}
	}
};
///////////////////////////////////////////////////////////

[3hM2Nwbp]

I don't see a copy constructor in your fArray class. That very may well be your issue, since your class isn't POD.

You'll notice that often assignment operators and copy constructors go hand in hand. You'll also want to note that these operators don't meet the strong guarantee.

fArray(const fArray& rhs)
{
  delete[] data;
  length = rhs.getLength();
  data = new mType[length]; // <- If this throws, *this is now in a bad state.
  for(int i = 0; i < length - 10; i++) // Why length - 10?
    data[i] = rhs.getValue(i);
}

[fredhenry]

Thankyou very much, I didn't know about copy constructors.

the following works

        fArray(const fArray& rhs){
		length = rhs.length;
		data = new mType[length];
		for(sli i =0;i<length;i++){
			data[i] = rhs.data[i];
		}
	}

I could only use the private variables/functions of rhs, I don''t know why, but it doesn't matter much anyway.