Инкапсуляция. Классы и их компоненты. Объекты

// CLS.H
 
class SIntArray
{
short int len, *arr;
 
public:
        void SetArr();
        void Input();
        void Output();
        void Delete();
        void OutputN();
};
 
 
// FUNC.CPP
 
#include <iostream.h>
#include "cls.h"
 
void SIntArray::SetArr()
{
 cout<<"Vvedite razmer massiva: ";
 cin>>len;
 arr = new short int[len];
 return;
}
 
void SIntArray::Input()
{
 cout<<"Vvedite dannie: \n";
 for(int i = 0; i < len; i++)
 {
  cout <<"A["<<i<<"] = ";
  cin >> arr[i];
 }
}
 
void SIntArray::Output()
{   
 cout << "Massiv: \n";
 for(int i = 0; i < len; i++)   
  cout <<"A["<<i<<"] = "<<arr[i]<<";\n";
}
 
void SIntArray::OutputN()
{
 cout << "Vivod elementa massiva: "; 
 int nom;
 cin >> nom;
 cout << "A["<<nom<<"] = "<<arr[nom]<<";\n";
}
 
void SIntArray::Delete()
{ 
 delete[] arr; 
 cout << "Massiv ydalen \n";
}
 
 
// PROJ1.CPP
 
#include <iostream.h>
#include "FUNC.cpp"
 
int main()
{
 SIntArray a;
  a.SetArr();
  a.Input();
  a.Output();
  a.OutputN();
  a.Delete();
 
 SIntArray* b;  
 int i;
 b = new SIntArray[i]; 
  b[i].SetArr();
  b[i].Input();
  b[i].Output();
  b[i].OutputN();
  b[i].Delete(); 
 delete[] b;
 
 SIntArray c[1];
  int k;
  c[k].SetArr();
  c[k].Input();
  c[k].Output();
  c[k].OutputN();
  c[k].Delete();
 
 SIntArray *d;
 {
  d = new SIntArray;
  d->SetArr();
  d->Input();
  d->Output();
  d->OutputN();
  d->Delete();
 }
 char e;
 cin>>e;
 return 0;
}

// Объявление класса iarray
 
#ifndef ARR_HPP
#define ARR_HPP
 
#include <iostream>
 
class iarray
{
 
public: // Публичные методы
    
    // Конструкторы - управляют инициализацией объектов класса
    iarray(size_t size = DEFAULT_SIZE);
    iarray(size_t size, const int* array);
    // Деструкторы - управляют зачисткой объектов класса
    ~iarray();
    
    // Ввод данных
    void setArray(int* array);
    // Вывод массива (константый метод)
    const int* getArray() const;
    // Вывод размера массива (константный метод)
    size_t size() const;
    
    // Перегруженный оператор доступа по индексу
    int& operator [] (size_t index);
    // Перегруженный дружественный оператор вывода в поток
    friend std::ostream& operator << (std::ostream& os, const iarray& rhs);
    
private: // Закрытые данные
    
    size_t  m_nSize; // Размер массива
    int*    m_pArr; // Массив
    static const size_t DEFAULT_SIZE = 10; // Значение по умолчанию для размера
};
 
#endif

// Реализация класса iarray
 
#include "arr.hpp"
 
#include <stdexcept>
 
iarray::iarray(size_t size)
    : m_nSize(size)
{
    m_pArr = new int[m_nSize];
}
 
iarray::iarray(size_t size, const int* array)
    : m_nSize(size)
{
    m_pArr = new int[m_nSize];
    for(size_t i = 0; i < m_nSize; ++i)
        m_pArr[i] = array[i];
}
 
iarray::~iarray()
{
    delete[] m_pArr;
}
 
void iarray::setArray(int* array)
{
    for(size_t i = 0; i < m_nSize; ++i)
        m_pArr[i] = array[i];
}
 
const int* iarray::getArray() const
{
    return m_pArr;
}
 
size_t iarray::size() const
{
    return m_nSize;
}
 
int& iarray::operator [] (size_t index)
{
    if(index >= m_nSize) // Если индекс превышает максимально допустимый...
        throw std::runtime_error("Index is out of range"); // ...то выбрасывается исключение
    return m_pArr[index];
}
 
std::ostream& operator << (std::ostream& os, const iarray& rhs)
{
    for(size_t i = 0; i < rhs.m_nSize; ++i)
        os << "#" << i + 1 << " -> " << rhs.m_pArr[i] << std::endl;
    return os;
}

// Пример использования разработанного класса
 
#include <iostream>
#include <ctime>
#include <cstdlib>
#include "arr.hpp"
 
int main()
{
    srand(static_cast<size_t>(time(NULL)));
    size_t sz = 15;
    iarray a1(sz);
    for(size_t i = 0; i < a1.size(); ++i)
        a1[i] = rand() % sz + sz;
    const int* a2 = a1.getArray();
    std::cout << "Generated array:\n( ";
    for(size_t i = 0; i < a1.size(); ++i)
        std::cout << a2[i] << " ";
    std::cout << ")" << std::endl;
    iarray a3(a1.size(), a2);
    std::cout << a3;
    return EXIT_SUCCESS;
}

int main()
{
 SIntArray a;
  a.SetArr();
  a.Input();
  a.Output();
  a.OutputN();
  a.Delete();
 
 SIntArray* b;  
 int i;
 b = new SIntArray[i]; 
  b[i].SetArr();
  b[i].Input();
  b[i].Output();
  b[i].OutputN();
  b[i].Delete(); 
 delete[] b;
 
 SIntArray c[1];
  int k;
  c[k].SetArr();
  c[k].Input();
  c[k].Output();
  c[k].OutputN();
  c[k].Delete();
 
 SIntArray *d;
 {
  d = new SIntArray;
  d->SetArr();
  d->Input();
  d->Output();
  d->OutputN();
  d->Delete();
 }
 char e;
 cin>>e;
 return 0;
}

#include <iostream>
#include <ctime>
#include <cstdlib>
#include "arr.hpp"
 
void randomArray(int* iarr, size_t sz)
{
    for(size_t i = 0; i < sz; ++i)
        iarr[i] = rand() % sz + sz;
}
 
int main()
{
    srand(static_cast<size_t>(time(NULL)));
    const size_t n = 8;
    int initArr[n];
    
    // Автоматический объект
    randomArray(initArr, n);
    iarray autoArr(n, initArr);
    std::cout << autoArr << std::endl;
    
    // Указатель на существующий объект
    iarray* pautoArr = &autoArr;
    // Можно повторно его инициализировать
    randomArray(initArr, n);
    pautoArr->setArray(initArr);
    std::cout << (*pautoArr) << std::endl;
    
    // Динамический объект
    randomArray(initArr, n);
    iarray* pdynArr = new iarray(n, initArr);
    std::cout << (*pdynArr) << std::endl;
    // Деструктор динамического объекта нужно вызывать явно:
    delete pdynArr;
    
    // Массив объектов
    iarray arr3[3];
    for(size_t i = 0; i < 3; ++i)
    {
        randomArray(initArr, n);
        arr3[i].resize(n); // Нужно написать метод resize
        arr3[i].setArray(initArr);
        std::cout << "#" << i + 1 << std::endl << arr[i] << std::endl;
    }
        
    // Объект внутри блока
    {
        randomArray(initArr, n);
        iarray inside(n, initArr);
        std::cout << inside << std::endl;
    }
    // std::cout << inside << std::endl; -- ошибка! - здесь объект уже не существует
    return EXIT_SUCCESS;
}

 SIntArray* b;  
 int i; // Переменная i - неинициализирована, в ней хранится "мусор"
 b = new SIntArray[i]; 
  // ...
 delete[] b;