Problem mit Array als Rückgabe

Die Antwort ist: Es gibt keine 2-Dimensionalen Arrays. Es gibt aber Arrays von Arrays.

// bar ist ein 6-elementiges Array von 6-elementigen Arrays von int
int bar[6][6];

Übergibst Du das einer Funktion:

void foo(int (*ptr)[6]);
...
foo(bar);

sieht das dann inklusive Zeiger ptr so aus im Speicher:

ptr                    ptr+1         ptr+5

    |                       |             |
    |                       |             |
    V                       V             V

  bar[0]_______________   bar[1]_ ...   bar[5]_______________
 /                     \ /             /                     \
+---+---+---+---+---+---+---+---+ ... +---+---+---+---+---+---+
|   | * |   |   |   |   |   |   |     |   |   |   |   |   | * |
+---+---+---+---+---+---+---+---+ ... +---+---+---+---+---+---+
      |                                                     |
  bar[0][1]                                             bar[5][5]

ptr ist ein Zeiger auf ein 6-elementiges Array von ints. Beachte, dass ptr[2] dasselbe ist wie *(ptr+2) . Und da ptr vom Typ int(*)[6] ist, sollte auch klar sein, was bei der Pointer-Arithmetik passiert. ptr[2] ist also ein Lvalue-Ausdruck für ein 6-elementiges int-Array. Damit kann man zB auch wieder eine Referenz initialisieren:

int (&arrayref)[6] = ptr[2];
arrayref[3] = 9;
assert(arrayref[3] == ptr[2][3]);

Jetzt sollte auch klar sein, warum man die Größe der "inneren Arrays" festlegen muss. Alles in der Richtung int (*ptr)[] ist völliger Quatsch. Du kannst eben keine Pointer-Arithmetik durchführen, wenn Du nicht weißt, wie groß ein Objekt des Typs ist, auf das der Zeiger zeigt.

kk

unskilled

machen könntest du es auch so:

#include <algorithm>
#include <iostream>
#include <iterator>

template<typename T>
struct divide
{
	divide(T divisor) : divisor(divisor) {}

	template<typename U>
	T operator() (U dividend) const
	{
		return static_cast<T>(dividend)/divisor;
	}
private:
	T divisor;
};

int main()
{
	int arr_src[] = { 0, 20, 40, 80, 160, 320 };
	const std::size_t size = sizeof arr_src/sizeof *arr_src;
	double arr_dst[size] = {0};

	std::transform(arr_src, arr_src+size, arr_dst, divide<double>(10.));

	std::copy(arr_dst, arr_dst+size, std::ostream_iterator<double>(std::cout, "\r\n"));
}

bb