Feldgröße ermitteln

problema

Hallo,

hoffentlich könnt ihr mir helfen. Ich möchte einer Funktion ein Integer-Array v übergeben und in dieser dann ermitteln wie lange v ist.

#include <iostream>

using namespace std;

void funktion(int v[])
{
    cout << sizeof(v) << sizeof(v[0]) << endl;
}

int main()
{
    int v[3] = {1,2,3};
    funktion(v);

    return 0;
}

Leider gibt mir

cout << sizeof(v) << sizeof(v[0]) << endl;

8 und 4. Da sollte aber

sizof(v)

=12 rauskommen, weil ich überall gelesen hab, dass bei

sizeof(v) / sizeof(v[0])

die Feldgröße=3 ermittelt werden kann.

Danke für eure Hilfe

mfg, problema

Hyde++ 0

Uebergibt man ein array an eine Funktion, wird daraus ein Zeiger auf das erste Element. Daher kann man hieraus erkennen, dass ein Zeiger bei dir 8 Byte, ein int 4 Byte gross ist.
Du musst die Groesse also der Funktion mit uebergeben.
Diese kannst du in dem Scope, in dem das Array erstellt wurde, ueber die von dir genannte Methode herauskriegen.

Alternativ:
Nutze std::array (oder boost::array) dann geht das, was du dir wuenschst:

#include <iostream>
#include <array>

using namespace std;

void funktion(array<int, 3> v)
{
    cout << v.size() << '\n';
}

int main()
{
    array<int, 3> = {1,2,3};
    funktion(v);

    return 0;
}

Wie du siehst, muss du natuerlich hier die Groesse angeben. Das wird dadurch ein wenig unsinnig. Wenn du ein dynamisches Array willst, willst du eigentlich std::vector.

daddy_felix

Machst du das aus akademischem Interesse oder möchtest du ein reales Problem lösen?

Skym0sh0

Ja, theoretisch kann man so auch die Größe ermitteln.

Problem ist nur, dass bei einer Parameterübergabe zu einer Funktion das Feld zu einem Pointer zerfällt. D.h. du hast einen Informationsverlust und musst dir die Länge des Feldes separat merken oder mit übergeben.

Um dem Problem zu entgehen kannst du std::array oder std::vector. Da gibt es Methoden, die dir die Größe zurückgeben.

problema

Das geht also nur im gleichen Scope oder ich muss das Array anders Definieren? Denn ich habe folgende Vorgaben:

int e1[2] = {1,2};
p.add(3,e1);

bei folgender Definitionsvorgabe:

Polynomial& add(int coeff, int* exps);

@daddy_felix: hobbymäßiges akademisches Interesse

Danke für eure Hilfe!

problema

Hat keiner einen Vorschlag wie das mit den Vorgaben zu realisieren ist

mfg

Jodocus

#include <iostream>

template <typename T, std::size_t N>
constexpr std::size_t array_size(T (&)[N]) {
	return N;
}

int main() {
	int arr[] = { 1, 2, 3 };
	std::cout << array_size(arr) << '\n';
}

Edit: Oder du bist ganz pro und benutzt std::vector/std::array. Dann hast du diese ganzen Probleme nicht mehr.

Columbo

@Jodocus: Funktioniert nicht für rvalues. Ich schlage

template <typename T>
constexpr std::size_t array_size(T&& t) {
    return sizeof t / sizeof *t;
}

vor.

Jodocus

Arcoth schrieb:

@Jodocus: Funktioniert nicht für rvalues. Ich schlage
template <typename T>
constexpr std::size_t array_size(T&& t) {
    return sizeof t / sizeof *t;
}
vor.

Ja und für dynamische Arrays sowieso nicht. Ist einfach insgesamt eine Schnappsidee, deswegen nochmal: std::vector und std::array.