Свой класс в С++

class IntArray
{
public:
    //Конструкторы класса
    explicit IntArray (int sz = DefaultArraySize);
    IntArray (int *array, int array_size);
    IntArray (const IntArray &rhs);
 
    //Деструктор класса
    ~IntArray() { delete[] ia; }
 
    //Операции сравнения:
    bool operator== (const IntArray&) const;
    bool operator!= (const IntArray&) const;
    int& operator[] (int index);
 
    //Операции присваиния:
    IntArray& operator= (const IntArray&);
 
    int size() const { return _size; }
    void sort();
 
    int min() const;
    int max() const;
 
    //функция find возвращает индекс первого
    //найденного элемента массива
    //или -1, если элемент не найден
 
    int find (int value) const;
 
private:
    static const int DefaultArraySize = 12;
    int _size;
    int *ia;
 
    void init (int sz,int *array);
};

#include <cassert>
 
void IntArray::init (int sz, int *array)
{
    _size = sz;
    ia = new int[_size];
 
    for (int ix=0; ix<_size; ++ix)
        if (!array)
            ia[ix] = 0;
        else
            ia[ix] = array[ix];
};
 
IntArray::IntArray (int sz) { init (sz,0); }
IntArray::IntArray (int *array, int array_size) { init (array_size,array); }
IntArray::IntArray (const IntArray &rhs) { init (rhs._size,rhs.ia); }
 
int& IntArray::operator[] (int index)
{
    assert (index >= 0 && index < _size);
    return ia[index];
}

#pragma hdrstop
 
#include <tchar.h>
#include "IntArray.h"
using namespace std;
//---------------------------------------------------------------------------
 
#pragma argsused
int _tmain(int argc, _TCHAR* argv[])
{
    int array0[10];
    IntArray array1[10];
    array1 = array0;
    return 0;
}

//---------------------------------------------------------------------------
 
#pragma hdrstop
 
#include <tchar.h>
#include <cassert>
#include <iostream>
using namespace std;
 
//------------------------------------------------------------------------------------------------------------------------------
//\/\/\/КАК МНЕ ЭТО ОПИСАНИЕ КЛАССА ВЫВЕСТИ В ОТДЕЛЬНЫЙ ФАЙЛ, ЧТОБЫ ЧЕРЕЗ #include МОЖНО БЫЛО ПОДКЛЮЧАТЬ\/\/\/
//------------------------------------------------------------------------------------------------------------------------------
class IntArray
{
public:
    //Конструкторы класса
    explicit IntArray (int sz = DefaultArraySize);
    IntArray (int *array, int array_size);
    IntArray (const IntArray &rhs);
 
    //Деструктор класса
    ~IntArray() { delete[] ia; }
 
    //Операции сравнения:
    bool operator== (const IntArray&) const;
    bool operator!= (const IntArray&) const;
    int& operator[] (int index);
 
    //Операции присваиния:
    IntArray& operator= (const IntArray&);
 
    int size() const { return _size; }
    void sort();
 
    int min() const;
    int max() const;
 
    //функция find возвращает индекс первого
    //найденного элемента массива
    //или -1, если элемент не найден
 
    int find (int value) const;
 
private:
    static const int DefaultArraySize = 12;
    int _size;
    int *ia;
 
    void init (int sz,int *array);
};
 
void IntArray::init (int sz, int *array)
{
    _size = sz;
    ia = new int[_size];
 
    for (int ix=0; ix<_size; ++ix)
        if (!array)
            ia[ix] = 0;
        else
            ia[ix] = array[ix];
};
 
IntArray::IntArray (int sz) { init (sz,0); }
IntArray::IntArray (int *array, int array_size) { init (array_size,array); }
IntArray::IntArray (const IntArray &rhs) { init (rhs._size,rhs.ia); }
 
int& IntArray::operator[] (int index)
{
    assert (index >= 0 && index < _size);
    return ia[index];
}
 
//------------------------------------------------------------------------------------------------------------------------------
// ^^^КАК МНЕ ЭТО ОПИСАНИЕ КЛАССА ВЫВЕСТИ В ОТДЕЛЬНЫЙ ФАЙЛ, ЧТОБЫ ЧЕРЕЗ #include МОЖНО БЫЛО ПОДКЛЮЧАТЬ^^^
//------------------------------------------------------------------------------------------------------------------------------
 
#pragma argsused
int _tmain(int argc, _TCHAR* argv[])
{
    int i;
    int array0[10];
    IntArray array1(50);
    IntArray array2(array0,10);
    for (i = 0; i < 10; i++)
        array2[i]=i;
    IntArray array3=array2;
    IntArray array4(10);
    cout << "array1 size: " << array1.size() << "\n";
    cout << "array2 size: " << array2.size() << "\n";
    cout << "array3 size: " << array3.size() << "\n";
    cout << "array4 size: " << array4.size() << "\n";
    system("pause");
    return 0;
}
//---------------------------------------------------------------------------

#ifndef INTARRAY_H
#define INTARRAY_H
// объявление класса..
 
#endif // это в конце

//Unit1.cpp
#include "IntArray.h"
//...

//IntArray.h
#include /*Что вы здесь поставите*/

//IntArray.cpp
#include /*Или здесь поставите*/

//Unit1.cpp
#include "IntArray.h"
//...

//IntArray.h
//ничего

//IntArray.cpp
#include "IntArray.h"

#ifndef INTARRAY_H
#define INTARRAY_H
class IntArray
{
public:
        //Конструкторы класса
        explicit IntArray (int sz = DefaultArraySize);
        IntArray (int *array, int array_size);
        IntArray (const IntArray &rhs);
 
        //Деструктор класса
        ~IntArray() { delete[] ia; }
 
        //Операции сравнения:
        bool operator== (const IntArray&) const;
        bool operator!= (const IntArray&) const;
        int& operator[] (int index);
 
        //Операции присваиния:
        IntArray& operator= (const IntArray&);
 
        int size() const { return _size; }
        void sort();
 
        int min() const;
        int max() const;
 
        //функция find возвращает индекс первого
        //найденного элемента массива
        //или -1, если элемент не найден
 
        int find (int value) const;
 
private:
        static const int DefaultArraySize = 12;
        int _size;
        int *ia;
 
        void init (int sz,int *array);
};
#endif

#include "IntArray.h"
#include <cassert>
void IntArray::init (int sz, int *array)
{
        _size = sz;
        ia = new int[_size];
 
        for (int ix=0; ix<_size; ++ix)
                if (!array)
                        ia[ix] = 0;
                else
                        ia[ix] = array[ix];
};
 
IntArray::IntArray (int sz) { init (sz,0); }
IntArray::IntArray (int *array, int array_size) { init (array_size,array); }
IntArray::IntArray (const IntArray &rhs) { init (rhs._size,rhs.ia); }
 
int& IntArray::operator[] (int index)
{
        assert (index >= 0 && index < _size);
        return ia[index];
}

#include "main.h"
#include "uGraham.h"

#include "uGraham.h"

#pragma hdrstop
#pragma argsused
 
#include <tchar.h>
#include <stdio.h>
#include "IntArray.h"
#include <iostream>
 
int _tmain(int argc, _TCHAR* argv[])
{
    int i;
    int array0[10];
    IntArray array1(50);
    IntArray array2(array0,10);
    for (i = 0; i < 10; i++)
        array2[i]=i;
    IntArray array3=array2;
    IntArray array4(10);
    std::cout << "array1 size: " << array1.size() << "\n";
    std::cout << "array2 size: " << array2.size() << "\n";
    std::cout << "array3 size: " << array3.size() << "\n";
    std::cout << "array4 size: " << array4.size() << "\n";
    system("pause");
    return 0;
}

//---------------------------------------------------------------------------
 
#pragma hdrstop
 
#include "IntArray.h"
#include <cassert>
//---------------------------------------------------------------------------
#pragma package(smart_init)
    void IntArray::init (int sz, int *array)
    {
            _size = sz;
            ia = new int[_size];
 
            for (int ix=0; ix<_size; ++ix)
                    if (!array)
                            ia[ix] = 0;
                    else
                            ia[ix] = array[ix];
    };
 
    IntArray::IntArray (int sz) { init (sz,0); }
    IntArray::IntArray (int *array, int array_size) { init (array_size,array); }
    IntArray::IntArray (const IntArray &rhs) { init (rhs._size,rhs.ia); }
 
    int& IntArray::operator[] (int index)
    {
            assert (index >= 0 && index < _size);
            return ia[index];
    }

//---------------------------------------------------------------------------
 
#ifndef IntArrayH
#define IntArrayH
//---------------------------------------------------------------------------
class IntArray
{
public:
        //Конструкторы класса
        explicit IntArray (int sz = DefaultArraySize);
        IntArray (int *array, int array_size);
        IntArray (const IntArray &rhs);
 
        //Деструктор класса
        ~IntArray() { delete[] ia; }
 
        //Операции сравнения:
        bool operator== (const IntArray&) const;
        bool operator!= (const IntArray&) const;
        int& operator[] (int index);
 
        //Операции присваиния:
        IntArray& operator= (const IntArray&);
 
        int size() const { return _size; }
        void sort();
 
        int min() const;
        int max() const;
 
        //функция find возвращает индекс первого
        //найденного элемента массива
        //или -1, если элемент не найден
 
        int find (int value) const;
 
private:
        static const int DefaultArraySize = 12;
        int _size;
        int *ia;
 
        void init (int sz,int *array);
};
#endif