float matrix[10][9]={   {1,1,0,0,0,0,0,1,0},
                        {1,0,0,1,0,0,0,0,0},
                        {0,0,0,1,0,1,0,1,1},
                        {0,0,1,0,0,0,0,0,0},
                        {0,0,0,1,0,0,0,0,1},
                        {0,0,1,0,0,0,1,0,0},
                        {0,0,0,0,0,1,0,0,0},
                        {0,1,0,0,1,0,1,0,0},
                        {0,0,0,0,0,0,0,1,0},
                        {0,0,0,0,0,0,0,0,1} };

wenn ich diese Matrix nun an eine Funktion übergeben will und dabei konvertiere, kommt Müll raus:

funktion((float**)matrix, 10);

also bei sowas zb:

for(int c = 0; c < 10; c++) {
		for(int i = 0; i < 9; i++)
			std::cout<<" M: "<<matrix[c];
		std::cout<<std::endl;
	}

wird statt (das ist der Fall, bevor ich konvertiere):

M: 0x605b60 M: 0x605b60 M: 0x605b60 M: 0x605b60 M: 0x605b60 M: 0x605b60 M: 0x605b60 M: 0x605b60 M: 0x605b60
 M: 0x605b84 M: 0x605b84 M: 0x605b84 M: 0x605b84 M: 0x605b84 M: 0x605b84 M: 0x605b84 M: 0x605b84 M: 0x605b84
 M: 0x605ba8 M: 0x605ba8 M: 0x605ba8 M: 0x605ba8 M: 0x605ba8 M: 0x605ba8 M: 0x605ba8 M: 0x605ba8 M: 0x605ba8
 M: 0x605bcc M: 0x605bcc M: 0x605bcc M: 0x605bcc M: 0x605bcc M: 0x605bcc M: 0x605bcc M: 0x605bcc M: 0x605bcc
 M: 0x605bf0 M: 0x605bf0 M: 0x605bf0 M: 0x605bf0 M: 0x605bf0 M: 0x605bf0 M: 0x605bf0 M: 0x605bf0 M: 0x605bf0
 M: 0x605c14 M: 0x605c14 M: 0x605c14 M: 0x605c14 M: 0x605c14 M: 0x605c14 M: 0x605c14 M: 0x605c14 M: 0x605c14
 M: 0x605c38 M: 0x605c38 M: 0x605c38 M: 0x605c38 M: 0x605c38 M: 0x605c38 M: 0x605c38 M: 0x605c38 M: 0x605c38
 M: 0x605c5c M: 0x605c5c M: 0x605c5c M: 0x605c5c M: 0x605c5c M: 0x605c5c M: 0x605c5c M: 0x605c5c M: 0x605c5c
 M: 0x605c80 M: 0x605c80 M: 0x605c80 M: 0x605c80 M: 0x605c80 M: 0x605c80 M: 0x605c80 M: 0x605c80 M: 0x605c80
 M: 0x605ca4 M: 0x605ca4 M: 0x605ca4 M: 0x605ca4 M: 0x605ca4 M: 0x605ca4 M: 0x605ca4 M: 0x605ca4 M: 0x605ca4

sowas ausgegeben (das passiert in der Funktion):

M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000
 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0 M: 0
 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000 M: 0x3f80000000000000

Wie kann ich korrekt konvertieren?

Ich habe jetzt keine Lust nochmal alles durchzukauen. Das gibt es hier immer wieder. (Werde schnell schauen, ob ich es finde).

EDIT:
Ging schnell: http://www.c-plusplus.net/forum/viewtopic-var-t-is-212469-and-highlight-is-doppelpointer.html

hmm, schade. mir war schon klar, dass beides nicht das gleiche ist, aber ich würde gerne doch wissen ob es ne möglichkeit gibt, die daten zu konvertieren, denn scheinbar hängt ein array von den adressen her sehr dicht aneinander.
weil ich die daten nicht einzeln verarbeite, müsste ich also bisher - langsam - in ein anderes 2D-array umkopieren.
folglich denke ich an soetwas wie memset.

Arrays können NUR als per Reference übergeben werden.
Jede Variante, die ich im Link gepostet habe, übergibt nicht mehr als einen Zeiger. (Abgesehen von den int's)

template<typename T, std::size_t N>
class Array2dRef2Ptr
{
public:
    template<std::size_t M>
    Array2dRef2Ptr(T (&a)[N][M])
    {
        std::copy( a, a + N, ptr_ ); // hier wird nichts kopiert
    }
    operator T**() { return ptr_; }
private:
    T* ptr_[N];
};

template<typename T, std::size_t N, std::size_t M>
Array2dRef2Ptr< T, N > array2ptr(T (&a)[N][M])
{
    return a;
}

...

funktion(array2ptr(matrix), 10); // ohne Cast

Die beste Lösung ist aber immer noch, funktion geeignet anzupassen.