Редкие массивы и матрицы

Question

Мне нужна помощь с программой, которая позволяет пользователю произвольно читать доступ к любой записи массива. Если пользователь пытается прочитать за пределами полезной области, ваша структура данных должна вернуть 0. Также он позволяет произвольному произвольному доступу записи к полезной области. Если пользователь пытается записать что-то в той части массива, которая должна быть 0, напечатайте сообщение об ошибке. , кроме того, программа должна иметь конструктор, который принимает параметры массива только как входные данные и инициализирует весь массив равным 0. Второй конструктор должен дополнительно принимать в качестве входных данных массив из ints, копируя его значения в полезную часть массива, который вы делаете ,

Это форма массива

[ 0 0 0 0 ... 0 0 1 2 3 4 5 0 0 .... 0 0 ] 

Я не знаю, как создать разреженный массив, и я не хочу использовать существующие библиотеки.

Я попытался создать динамический массив, в котором используется оператор Overload, но моя проблема в том, что я даже не знаю, что такое разреженный массив и как его создать.

#include <iostream> 

using namespace std; 

class MyArray 
{ 
    friend ostream& operator<< (ostream &os, MyArray &array); 

    public: 
     MyArray (int size); 
     MyArray (const MyArray &rhs); 
     ~MyArray(); 

     MyArray& operator= (const MyArray& rhs); 
     int& operator[] (int index); 
     int read_element (int index); 
     void write_element (int index, int value); 

    private: 
     int *storage; 
     int size; 
}; 

#include "sparse_array_1d.h" 

MyArray::MyArray (int size) 
{ 
    storage = new int[size]; 
    this->size = size; 
} 

MyArray::MyArray (const MyArray &rhs) 
{ 
    size = rhs.size; 
    storage = new int[size]; 
    (*this) = rhs; 
} 

MyArray::~MyArray() 
{ 
    delete [] storage; 
} 

int MyArray::read_element (int index) 
{ 
    return storage[index]; 
} 

void MyArray::write_element (int index, int value) 
{ 
    storage[index] = value; 
} 

MyArray& MyArray::operator= (const MyArray &rhs) 
{ 
    int i,min_size; 

    if (size < rhs.size) 
     min_size = size; 
    else 
     min_size = rhs.size; 

    for (i=0; i<min_size; i++) 
     storage[i] = rhs.storage[i]; 

    return (*this); 
} 

int& MyArray::operator[] (int index) 
{ 
    if (index < size && index >=0) 
     return storage[index]; 

    return storage[0]; 
} 

ostream& operator<< (ostream &os, MyArray &array) 
{ 
    int i; 

    os << "[ "; 

    for (i=0; i<array.size; i++) 
     os << array[i] << " "; 

    os << "]" << endl; 
    return os; 
} 

#include <iostream> 
#include "sparse_array_1d.h" 

using namespace std; 

int main() 
{ 
    int i,size; 

    cout << "What array sizes would you like?" << endl; 
    cin >> size; 

    MyArray p1 (size); 

    //int q=1; 
    for (i=0; i<size; i++) 
    { 
     p1[i] = 0; 
     //q++; 
    } 

    cout << "p1: " << endl; 
    cout << p1; 

    int x; 

    cout << endl; 
    cout << "enter numbers : " << endl; 

    for (i=0 ; i<size; i++) 
    { 
     cin >> p1[i]; 
    } 

    cout << "This is the array" << endl; 
    cout << p1; 
    cout << endl; 

    return 0; 
} 

Answer 1

я думаю, что вектор класса плюс некоторые if должны делать все, что вы хотите, нет необходимости, чтобы воссоздать его. Вы можете использовать два вектора: один для хранения элементов и один для сохранения их положения.

vector<int> values,positions; 
int c,success; 

cout<<"Insert element"<<endl; 
cin>>c; 
positions.push_back(c); 
cout<<"Insert value"<<endl; 
cin>>c; 
values.push_back(c); 

cout<<"Which element you want to read?"<<endl; 
cin>>c; 
success=0; 
for(int i=0;i<values.size();;i++){ 
if(positions[i]==c){ 
cout<<values[i]<<endl; 
success=1; 
} 
if(success==0) 
cout<<"Out of bounds: 0"<<endl; 

Answer 2

Как ни странно, я считаю, что мы в одном классе. Но слушайте, вы уже, вероятно, создали разреженный массив, когда вы динамически инициализировали массив до определенного пользователем размера (int N;) и всех нулей.

Поскольку вы сразу же заполнили все элементы N как ноль, вы начали использовать разреженный массив. После первого выполнения вашим конструктором ваш деструктор автоматически (ну, если вы его построили) очищает всю память от массива. Таким образом, у вас есть массив из N слотов элементов, готовых принять N элементов. Однако до тех пор все области слотов элементов в основном пусты и, следовательно, не используют память. Но массив все еще существует, следовательно, ваш разреженный массив.