динамический масив

[mixon-21]

подскажите пожалуста где ошибка

#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;
class myMas
{
public:
myMas();
~myMas();

private:
int **size;
int m;
};

myMas::myMas()
{
	srand(time(NULL));
int **size=new int*[10];
for(int i=0;i<10;i++)
{
	size[i]=new int [i];
	cout<<size[i];
}
}

myMas::~myMas()
{
for(int i=0;i<10;i++)
{
delete [] size[i];
}
delete [] size;
}

void main()
{
	myMas ekz;
	ekz.~myMas();
system ("pause");
}

[Helloween]

ekz.~myMas();

Деструктор так не вызывают, он сам вызовется в данном случае.

cout<<size[i];

Вы пытаетесь вывести массив.

[mixon-21]

Вы пытаетесь вывести массив.

Да пытаюсь вывести на екран , а как правильно???

все ровно ошибка

#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;
class myMas
{
public:
myMas();
~myMas();

private:
int **size;
int m;
};

myMas::myMas()
{
	srand(time(NULL));
int **size=new int*[10];
for(int i=0;i<10;i++)
{
	size[i]=new int [i];
	cout<<size[i];
}
}

myMas::~myMas()
{
for(int i=0;i<10;i++)
{
delete [] size[i];
}
delete [] size;
}

void main()
{
	myMas ekz;
	
system ("pause");
}

[Helloween]

srand(time(NULL));
int **size=new int*[10];
for(int i=0;i<10;i++)
{
	size[i]=new int [i];
        for(int j =0 ; j < i; j++)
       {
          size[i][j] = rand()%10; 
	  cout<<size[i][j];
       }
}
}

[Helloween]

#include "stdlib.h"
#include "iostream.h"
#include "time.h"
#include "iomanip.h"

template <typename T>
class new_allocator
{
public:
	static T* allocate(size_t size)
	{
		_arr = true;
		return new T[size];
	}
	static T* allocate()
	{
		return new T();
	}
	static void deallocate(T* ptr)
	{
		if(_arr)
			delete [] ptr;
		else
			delete ptr;	
    }
private:
	static bool _arr;		
};
template <typename T>
bool new_allocator<T>::_arr = false;

template
<
	typename T,
	template <class> class allocator_
>
class TArr
{
public:
	TArr() : _arr(NULL), _size(0) {}
	TArr(size_t size) : _size(size)
	{
	   _arr = allocator_<T*>::allocate(size);
	   srand(time(NULL));
	   for(size_t i = 0; i < size; i++)
	   {
			_arr[i] = allocator_<T>::allocate(size);
			for(size_t j = 0; j < size; j++)
				_arr[i][j] = rand()%100 + 1;
       }
	}
	
	TArr(const TArr& ra)
	{
		operator=(ra);
	}

	TArr& operator= (const TArr& ra)
	{
		free();
		_arr = allocator_<T*>::allocate(ra._size);
		_size = ra._size;
		for(size_t i = 0; i < _size; i++)
		{
			_arr[i] = allocator_<T>::allocate(_size);
			memcpy(_arr[i],ra._arr[i],sizeof(T)*_size);
		}
        return *this;
	}
	~TArr()
	{
         free();
	}
	void print() const
	{
		if(_arr)
		{
			for(size_t i = 0; i < _size; i++)
			{
				for(size_t j = 0; j < _size; j++)
					std::cout<<std::setw(4)<<_arr[i][j];
				std::cout<<std::endl;
			}
		}
	}
private:
	void free()
	{
        if(_arr)
		{
			for(size_t i = 0; i < _size; i++)
				allocator_<T>::deallocate(_arr[i]);
			allocator_<T*>::deallocate(_arr);
		}
	}
private:
	T** _arr;
	size_t _size;
};

typedef TArr<int,new_allocator> TIntArr;

int main()
{
  TIntArr ta(10);
  ta.print();
  TIntArr ta2(13);
  ta = ta2;
  ta.print();
  return 0;
}

[mixon-21]

А как теперь перегрузить operator+

#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;
class myMas
{
public:
myMas(int n);
~myMas();
int operator[](int ar);
myMas& operator+(const myMas& ar);
void display();
private:
int *size;
int m;
int count;
};
 
myMas::myMas(int n)
{
size=new int[n];
count=n;
}
 
 
myMas::~myMas()
{
delete [] size;
}
int myMas::operator[](int ar)
{
    return myMas::size[ar];
}
 
myMas& myMas::operator+(const myMas& ar)
{
    return *this;
}
void myMas::display()
{
    srand(time(NULL));
    for(int i=0;i<myMas::count;i++)
    {
        myMas::size[i]=rand()%10;
         cout << myMas::size[i] <<' ';
    }
}
void main()
{
    myMas ekz=myMas(5),ekz1=myMas(2),ekz2=ekz+ekz1;
 
    ekz2.display();
 
system ("pause");
}

где operator+ (добавление элемента в конец массива),