Deklarowanie wielkości tablicy w macierzy C++

Question

Cześć chciałbym żeby użytkownik miał możliwość samemu deklarować wielkość tablicy, zeby nie była ona narzucona z góry. W jaki najprostszy sposób można to wykonać? Próbowałem poprzez konstruktor, ale niestety nic nie wychodziło. Prosze o wyrozumiałość, z góry dzięki.

 

#include <iostream>
using namespace std;

class Klasa
{
    public:
    int macierz[10][10];
    int wiersz, kolumna;

    void setter()
    {
        cout<<"Podaj ilosc wierszy: "<<endl;
        cin>>wiersz;
        cout<<"Podaj ilosc kolumn: "<<endl;
        cin>>kolumna;

        for(int i=0; i<wiersz; i++)
            for(int j=0; j<kolumna; j++)
            {
                cout<<"Podaj wartosc dla "<<i+1<<" "<<j+1<<" w macierzy: "<<endl;
                cin>>macierz[i][j];

            }
    }

    void getter()
    {
        cout<<endl<<"MACIERZ: "<<wiersz<<" x "<<kolumna<<endl;
        for (int i=0; i<wiersz; i++)
            for (int j=0; j<kolumna; j++)
            {
                cout<<macierz[i][j]<<" ";
                if(j==kolumna-1) cout<<endl;
            }

    }


};

 int main()
 {
     Klasa m1;

     m1.setter();
     m1.getter();

    return 0;
}

 

Answer 1

Możesz to zrobić na bardzo wiele sposobów.

Na początek pewnie taki jakiego uczy się do dziś. Niskopoziomowe, brzydkie "wachlowanie new i delete" i wskaźniki na wskaźniki:

#include <iostream>
#include <iomanip>

class Matrix {
public:
    Matrix(size_t height, size_t width)
        : max_height(height), max_width(width) {

        data = new int*[max_height]();
        for(size_t rowIdx = 0; rowIdx < max_height; ++rowIdx) {
            data[rowIdx] = new int[max_width]();
        }

    }

    int& valueAccess(size_t height, size_t width) const {
        return data[height][width];
    }

    void show() const {
        // Implementacja testowa dla prezentacji rozwiązania.
        for(size_t rowIdx = 0; rowIdx < max_height; ++rowIdx) {
            for(size_t colIdx = 0; colIdx < max_width; ++colIdx) {
                std::cout << std::setw(8) << data[rowIdx][colIdx];
            }
            std::cout << '\n';
        }

    }

    ~Matrix() {

        for(size_t rowIdx = 0; rowIdx < max_height; ++rowIdx) {
            delete [] data[rowIdx];
        }
        delete [] data;

    }
private:
    size_t max_height;
    size_t max_width;
    int ** data;
};

int main() {
    Matrix matrix(7, 12);
    matrix.valueAccess(5, 5) = 20;
    matrix.show();
}

W kodzie chodzi mi tylko o pokazanie sposobu alokacji danych. Jak widzisz to podejście wymaga dokładnego sprzątania w destruktorze i ... uwierz mi.. ma bardzo wiele wad. Trzeba mieć poważne powody by tak programować.

Pierwszą poprawką będzie "spłaszczenie tablicy" tak aby nie była wielowymiarowa a jedynie prezentowana była wielowymiarowo. Zwróć uwagę na sposób dostępu do elementów:

#include <iostream>
#include <iomanip>

class Matrix {
public:
    Matrix(size_t height, size_t width)
        : max_height(height), max_width(width) {

        data = new int[height * width]();

    }

    int& valueAccess(size_t height, size_t width) const {
        return data[height * max_height + width];
    }

    void show() const {
        // Implementacja testowa dla prezentacji rozwiązania.
        for(size_t rowIdx = 0; rowIdx < max_height; ++rowIdx) {
            for(size_t colIdx = 0; colIdx < max_width; ++colIdx) {
                std::cout << std::setw(8) << valueAccess(rowIdx, colIdx);
            }
            std::cout << '\n';
        }

    }

    ~Matrix() {

        delete [] data;

    }
private:
    size_t max_height;
    size_t max_width;
    int * data;
};

int main() {
    Matrix matrix(7, 12);
    matrix.valueAccess(5, 5) = 20;
    matrix.show();
}

Już jest lepiej.

Oczywiście lepiej jeszcze użyć std::array czy std::vector ale zaraz (zapewne) odpowiesz "nie mieliśmy/nie wolno" :)

Answer 2

Poczytaj o dynamicznej alokacji pamięci lub o kontenerach STL.

Answer 3

Dynamiczna alokacja. Użyj operatora new.

int* tab;

tab = new int[dataFromUser];

delete []tab;

Answer 4

chodziło ci mniej więcej o coś takiego?

#include <iostream>

using namespace std;

int main ()
{
      int wiersze,kolumny;
      cin >> wiersze>> kolumny;
      int tab[kolumny][wiersze];
      // reszta kodu
}

 

Comments

Spójrz na odpowiedź która ma 5 minusów -_-

---

widziałem tą odpowiedź. tam pomysł był zły o tyle, że chciał przypisać rozmiar tablicy po zadeklarowaniu jej istnienia (co wiem że się nie da). Ja zaproponowałem rozwiązanie, żeby wprowadzić liczby, z których dopiero powstanie taka tablica. Odpowiedz, czy to rozwiązanie też jest złe?

---

Źle zinterpretowałeś jego komentarz.
Mu chodziło dokładnie o to samo co tobie.
Twoje jest źle. Normalny kompilator by wyrzucił błąd.
Wielkość normalnej tablicy mus być znana w czasie kompilacji.
Jak chcesz wczytać rozmiar od użytkownika, użyj dynamicznej alokacji:
 

int size;
std::cin >> size;
int *tab = new int[size];


delete[] tab;

 

---

to dziwne, bo mi wcześniej opisany sposób działa (używam CodeBlocks). Jednak to prawda, że lepiej użyć dynamicznej alokacji. Dziękuje za odpowiedź i przepraszam za wprowadzanie w błąd

---

Bo kompilator to za ciebie naprawia. Nie rób tego po prostu :D

Answer 5

Spróbuj zadeklarować w ten sposób:

int rozmiar;

float tab[rozmiar];

Użytkownik, jako dane niech wprowadzi - np. rozmiar = 100.

Wtedy miałby tab[100].

Comments

Przed napisaniem odpowiedzi, upewnij się, że masz jakiekolwiek pojęcie co piszesz. To powinno być w regulaminie

---

Widziałem takie rozwiązania, a wszystko zależy od kontekstu i sytuacji. Dlatego użyłem słowa "Spróbuj".

---

To jest niepoprawne. Są kompilatory które to skompilują, ale założenie jest takie, że to się nie skompiluje. Wielkość tablicy musi być znana w czasie kompilacji.