Safe Arrays

    
void AddOne(SafeArray <int> sarray) {
	int i;
	for (i=0;i<sarray.size();i++) {
		sarray[i]++;
	}
}

SafeArray <double> CreateSquareRoots(int num) {
	SafeArray<double> returnarray(num);
	int i;
	for (i=0;i<num;i++) {
		returnarray[i]=sqrt(i);
	}
	return returnarray;
}

int main(int argc, char *argv[]) {
	
	int i;
	printf("Hello world!\n");
	
	SafeArray <int> Simple(2);
	Simple[0]=1;
	Simple[1]=5;
	printf("Simple[1]=%d\n",Simple[1]); //should say 5

	AddOne(Simple);
	printf("Simple[1]=%d\n",Simple[1]);  //should say 6

	printf("Simple[1]=%d\n",Simple[3]);  //should still say 6

	printf("Simple[1]=%d\n",Simple[-5]); //should still say 6


	
	SafeArray <double> Roots;
	Roots = CreateSquareRoots(5);
	printf("Roots[4]=%g\n",Roots[4]); //should say 2

	

	float stack_array_from_old_code[50];
	for (i=0;i<50;i++) stack_array_from_old_code[i]=i*3.0f;
	SafeArray <float> StackArray;
	StackArray.SetArray(stack_array_from_old_code,50,false);
	printf("StackArray[3]=%g\n",StackArray[3]); //should say 9


	float *dynamic_array_from_old_code = new float [50];
	for (i=0;i<50;i++) dynamic_array_from_old_code[i]=i*2.0f;
	SafeArray <float> DynamicArray;
	DynamicArray.SetArray(dynamic_array_from_old_code,50,true);
	printf("DynamicArray[40]=%g\n",DynamicArray[-40]); //should say 80


	//delete [] dynamic_array_from_old_code; //not needed: SafeArray takes care of this now.

	return 0;
}
  

  
template <class T> class SafeArray {
public:
	SafeArray() {
		array=NULL;
		varray=NULL;
		array_size=0;
		lastaccess=0;
		copies=NULL;
		manage=true;
	};
	SafeArray(const int size) {
#ifdef USE_MALLOC
		array=(T *)malloc(sizeof(T)*size);
#else
		array=new T[size];
#endif
		if (array==NULL) {
			varray=NULL;
			array_size=0;
			copies=NULL;
			manage=false;
		} else {
			varray = array;
			array_size=size;
#ifdef USE_MALLOC
			copies=(int *)malloc(sizeof(int));
#else
			copies=new int;
#endif
			*copies=1;
			manage=true;
//			printf(" 0x%x: copies:%d\n",this,*copies);

		}
		lastaccess=0;
	}
	SafeArray(SafeArray &other) {
		manage=other.manage;
		array_size=other.array_size;
		lastaccess=other.lastaccess;
		varray = other.varray;
		(*other.copies)++;
		copies=other.copies;
		array= (T*)varray;
//		printf(" 0x%x: copies:%d\n",this,*copies);

	}
	~SafeArray() {
		if (copies==NULL) 
			return;
		(*copies)--;
//		printf("~0x%x: copies:%d\n",this,*copies);

		if ((varray)&&((*copies)<=0)&&(manage)) {
//			printf("i am deleteing myself\n");

#ifdef USE_MALLOC
			free(varray);			
			free(copies);
#else
			delete [] array;
			delete copies;
#endif
			varray=NULL;
			array=NULL;
		}
	}
	void SetArray(T *old_array, const int size, const bool dynamic=false) {
		varray=old_array;
		array_size=size;
		lastaccess=0;
		array= (T*)varray;
		manage=dynamic;
		if (manage) {
#ifdef USE_MALLOC
			copies=(int *)malloc(sizeof(int));
#else
			copies=new int;
#endif
			*copies = 1;
		}
	}
	T & operator [] (const int x) {
		lastaccess=((+1 | (x >> (sizeof(int) * 8 - 1))) * x) % array_size; //fast absolute value

		if (array) 
			return array[lastaccess];
	}
	void operator = (T val) {
		if (!array) return;
		array[lastaccess]=val;
	}
	void operator = (SafeArray &other) {
		manage=other.manage;
		array_size=other.array_size;
		lastaccess=other.lastaccess;
		varray = other.varray;
		(*other.copies)++;
		copies=other.copies;
		array= (T*)varray;
//		printf(" 0x%x: copies:%d\n",this,*copies);

	}
	const int size(void) {
		return array_size;
	}
private:
	int array_size;
	int lastaccess;
	int *copies;
	bool manage;
	void *varray;
	T *array;
};
  

    
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

using std::vector;
using std::transform;
using std::plus;
using std::bind2nd;
using std::cout;
using std::endl;

int main() {
    vector<int> simple(3);
    simple[0] = 1;
    simple[1] = 5;
    simple[2] = 11;

    transform(simple.begin(), simple.end(), simple.begin(), bind2nd(plus<int>(), 1));


    cout << "simple[0] = " << simple[0] << endl;
    cout << "simple[1] = " << simple[1] << endl;
    cout << "simple[2] = " << simple[2] << endl;

    return 0;
}
    

  
#include <vector>
#include <stdio.h>

using namespace std;

int main() {
 vector <int> x(3);
 x[1]=1;
 printf("hello world! %d",x[1]);
 return 0;
}