Ich wollte fragen ob es eine Möglichkeit gibt bei einfachen Funktionen die Länge eines Feldes so zu übergeben wie es zum Beispiel bei einem template Möglich wäre?
Ich meine das folgendermaßen:

Definition einr Funktion als Template:

template <size_t N>
int mat_operation(const double mat[N], double result[N])
{
    for(size_t i = 0; i < N; i++){
        result[i] = mat[i] * +1;
    }

    return 0;
}

Der Aufruf in der Main wäre dann in der Art:

int main(){
    double vektor[6] = {1,2,3,4,5,6};
    double vektor_plus1[6];

    mat_operations<6>(vektor, vektor_plus1);

    return 0;
}

Ist es nun möglich den Aufruf so wie er in der Main vollzogen wird (mit Übergabe der Vektorgröße in den dreieckigen Klammern) ohne ein Template hinzukriegen? Wie muss dann die Funktionsdeklaration aussehen?

Das Template funktioniert sehr gut, allerdings geht es mir um die Strukturierung und daher frage ich mich ob das was ich mit dem template erreiche eigentlich auch mit normalen Funktionen möglich ist.

EDIT//:

Im übrigen bin ich der Meinung dass bei std::arrays die Arraygröße mitgegeben werden muss.

Die mir vorliegende Implementierung arbeitet ohne STL mit einfachen Arrays. Ich möchte nicht alles ändern.

ok.

Freddy_Kay schrieb:

Im übrigen bin ich der Meinung dass bei std::arrays die Arraygröße mitgegeben werden muss.

diese Meinung hast du aber ziemlich exklusiv. Oder was genau spricht gegen die Verwendung von std::array::size?

Freddy_Kay schrieb:

Im übrigen bin ich der Meinung dass bei std::arrays die Arraygröße mitgegeben werden muss.

diese Meinung hast du aber ziemlich exklusiv. Oder was genau spricht gegen die Verwendung von std::array::size?

Wie überebe ich ein std::array an eine Funktion ohne bereits zur Compilezeit zu sagen wie groß das Array wird?

EDIT//:

Und bringt mich dass dann der Lösung meines ursprünglichen Problems näher?

man könnte natürlich mit data() und size() zur C-Lösung zurückgehen:

void doSomething(int* array, size_t n);

std::array<int, 3> arr = {1,2,3};
doSomething(arr.data(), arr.size());

oder im Stil der STL-Algorithmen Iteratoren übergeben:

doSomethingDifferent(arr.begin(), arr.end());

edit: hm... jetzt bin ich selber abgeschweift. Nein, deinem ursprünglichen Problem wird das wohl kaum weiterhelfen. sorry...

achso, das meinst du...

man könnte natürlich mit data() und size() zur C-Lösung zurückgehen:

void doSomething(int* array, size_t n);

std::array<int, 3> arr = {1,2,3};
doSomething(arr.data(), arr.size());

oder im Stil der STL-Algorithmen Iteratoren übergeben:

doSomethingDifferent(arr.begin(), arr.end());

Die erste Lösung ist sicher machbar und simpel. Ich wollte aber eben, dass die Arraygröße nicht als weiterer Parameter übergeben wird, sondern wie in der Templatelösung mit

funtction< int größe_des_array >(parameterliste)

Bzw. hab ich mich gefragt ob das auch bei normalen Funktionen möglich ist, oder halt eine Eigenschaft der Templates abbildet.

Für die zweite Lösung müsste ich dann, da das alles keine STL container sind, mit Zeigern arbeiten. Da bleib ich dann doch lieber beim Template.

Das geht nicht mit normalen Funktionen, weil N ja zur Compilezeit bekannt sein muss -> Templateparameter.

Alles klar. Danke an beide Poster!

Für die zweite Lösung müsste ich dann, da das alles keine STL container sind, mit Zeigern arbeiten. Da bleib ich dann doch lieber beim Template.

Zeiger oder Iterator, ist doch für Dich transparent.
C++11 kommt mit begin() und end() für Arrays (sind ansonsten aber auch trivial zu implementieren) und Du würdest bei einer Lösung bleiben, die typisch für C++ ist.

template <class T, size_t N> T* begin(T (&array)[N]) { return array; }
template <class T, size_t N> T* end(T (&array)[N]) { return array + N; }