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!

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

lern erst mal standart schreiben.

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

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.

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