Dynamisches Mehrdimensionales Array

*D*

Hallo,
ich habe mir noch mal die Erzeugung eines dynamischen mehrdimensionalen Arrays durchgelesen,
und mir kam eine Idee. Ich habe mir gedacht, am Anfang deklariert man ja nur das bla ein
Zeiger auf ein Array von Zeigern sein soll. Und diesen Einzelnen Zeigern gibt man dann
Arrays von einzelnen Werten:

int** bla;
bla = new int* [zeilen];

for (int i = 0; i < zeilen; ++i)
    bla[i] = new int [spalten];

Das sieht dann ja so aus:

**bla -> *bla[0] -> bla[0][0] -> bla[0][1] -> ...
         *bla[1] -> ...
         ...

(Ich habe das in Codetags eingeschlossen, damit die Einrückung erfolgt!)

Jetzt habe ich mir gedacht, man könnte die Spalten Anzahl verändern in der Schleife, dann
hätte man bei dem mehrdimensionalen Array kein "Rechteck" mehr, sondern ein "Dreick" o.ä.
In meinem Buch steht bei mehrdimensionalen Arrays, dass die Spaltenanzahl gleich bleibt.
Folgendes Programm funktioniert aber:

#include <iostream>

int main() {
	int** bla;
	int zeilen = 5;

	bla = new int*[zeilen];
	for (int i = 0; i < zeilen; ++i)
		bla[i] = new int[i+1];   // jeder bekommt unterschiedlich viele Elemente

	for (int i = 0; i < zeilen; ++i) 
		for (int j = 0; j < i+1; ++j) 
			bla[i][j] = i+j; // irgendwelche Werte zuweisen

	for (int i = 0; i < zeilen; ++i) {
		for (int j = 0; j < zeilen; ++j) {
			std::cout<<bla[i][j]<<" "; // funktioniert auch
		}
		std::cout<<"\n";
	}

	std::cin.get();
	return 0;
}

Gibt es jetzt in obigen Beispiel kein bla[0][2]? Oder gibt es diesen Wert, und ich habe in
einfach nicht verwendet? Warum funktioniert dann bla[i] = new int[i+1]. Da verändert sich doch die Größe!

Foxx90

ho wo ist denn dein delete[] ? SO sieht speicherbereinigung aber nicht aus

Zu deinem Problem:
Du willst wissen ob es [0][2] gibt ? Die Antwort ist nein ...

bla = new int*[zeilen];
    for (int i = 0; i < zeilen; ++i)
        bla[i] = new int[i+1];   // beim ersten durch gang ist i = 0... also wird
                                 // bla[0] = new int [0+1];
                                 // Somit wird dem ersten zeiger ein array mit
                                 // einem element zuzgewiesen !

Gruß Chris

bla... std::vector... bla bla nix delete
bla.. mehrdimensional -> eindimensional[x+y*width]

Foxx90

hoho da kennt jemand die standart library hoho
nur war das nicht gefragt ... wer lesen kann ist klar im vorteil

trotzdem ist std::vector besser.
lern erst mal standart schreiben.

Foxx90

Registrier du dich erstmal

drakon

lern erst mal standart schreiben.

http://de.wikipedia.org/wiki/Standard

Foxx90

Autsch!

drakon

Foxx90 schrieb:

Autsch!

Obwohl ich das gerne gemacht habe, muss ich zugeben, dass ER das mit Absicht falsch geschrieben hat.

Sonst wäre er nicht auf die Idee gekommen [ b] - Tags reinzumachen.

standard kann ja hier jeder schreiben

*D*Evil

Aber im ernst ... warum net 2d auf 1d blitten?

template<typename value_type>
struct array2
{
    typedef value_type value_t;
    typedef std::pair<std::size_t, std::size_t> dimension_t;

    value_t const& get(const std::size_t x, const std::size_t y) const { return m_data[y * m_size.first + x]; }
    value_t& at(const std::size_t x, const std::size_t y) { if (x > m_size.first || y > m_size.second) throw std::out_of_range("index"); return m_data[y * m_size.first + x]; } 
    value_t& operator()(const std::size_t x, const std::size_t y) { return m_data[y * m_size.first + x]; }
    value_t const& operator() (const std::size_t x, const std::size_t y) const { return m_data[y * m_size.first + x]; }

    array2(const std::size_t width, const std::size_t height, value_type const& default_value = value_type())
        : m_size(std::make_pair(width, height)), m_data(new value_type[width * height](default_value))
    {}
    ~array2() { delete [] m_data; }

    array2& operator=(array2 const& rhs)
    {
        if (this == &rhs) return *this;
        delete [] m_data;
        m_data = new value_type[rhs.m_size.first * rhs.m_size.second];
        m_size = rhs.m_size;
        std::copy(m_data, m_data + (m_size.first * m_size.second), rhs.m_data);
        return *this;
    }

    array2(array2 const& rhs)
        : m_size(rhs.m_size), m_data(new value_type[rhs.m_size.first * rhs.m_size.second])
    { std::copy(m_data, m_data + (m_size.first * m_size.second), rhs.m_data); }

private:
    value_t* m_data;
    dimension_t m_size;    
};

std::ostream& foo(std::ostream& out, array2<double> const& bar)
{ return out << bar.get(1, 2) }

int main()
{
    array2<double> data(10, 10, 1.0);
    std::cout << data(0, 1) << std::endl;
    std::cout << foo(data) << std::endl;
}

usw. ... ist viel schöner als so nen dummer 2d array ^^ aber noch einfacher:

std::vector< std::vector<double> > data;

_D