3. Problem mit Array als Rückgabe

Problem mit Array als Rückgabe

  • F

    Das frage ich mich auch.

    @oneill5000: Bei dir ist aber das Problem, dass mein num Array dann überschrieben wird, wenn ich mit Referenzen arbeite. Das möchte ich aber nicht.

    edit: Das gleiche gilt für das zweite Beispiel von Dweb. Du arbeitest zwar nicht mit Referenzen aber Du überschreibst es dennoch.

    edit2: Ich hab es zwar nicht ausprobiert, aber wird das Array im ersten Beispiel von Dweb nur lokal verändert?

    VIelen Dank
    lg, freakC++

    0
  • I

    theta schrieb:

    ipsec schrieb:

    Vorweg: es ist dringend anzuraten, das mit vector oder boost::array oder etwas Vergleichbarem zu machen.

    Aus reiner Neugier: Warum?
    Simon

    Einige wenige Punkt, die für vector und gegen eine händische Lösung sprechen:

    • (Exception-)Sicherheit
    • geringerer Aufwand
    • weniger Fehlerquellen
    • besseres Design
    • generell kein manuelles Speichermanagement notwendig (ist fast immer von Vorteil)
    • besser erweiter- und wartbar

    In puncto Performance ist eine vector -Rückgabe zwar schlechter bestellt (wenn die NRVO nicht greift), das ändert sich aber in C++0x mit Moving-Konstruktoren. Außerdem ist der Unterschied bei 6 Werten sowieso irrelevant.

    0
  • ?

    freakC++ schrieb:

    edit: Das gleiche gilt für das zweite Beispiel von Dweb. Du arbeitest zwar nicht mit Referenzen aber Du überschreibst es dennoch.

    Dann kannst du mein erstes Beispiel verwenden oder ebn dynamische Speicherverwaltung, wie in meinem ersten Post

    freakC++ schrieb:

    edit2: Ich hab es zwar nicht ausprobiert, aber wird das Array im ersten Beispiel von Dweb nur lokal verändert?

    Nein, wenn man dir schon eine Lösung anbietet, dann kannst du sie doch auch einfach schnell testen, ob's deinen Erwartungen entspricht. 👍

    0
  • F

    Ich denke auch, dass man std::vector mehr nutzen sollte, doch wie gesagt: Man muss beides können.

    edit: Klar, Du hast recht, Dweb. Ich wollte dir nur sagen 😉 😉 😉

    lg, freakC++

    0
  • F

    Hallo,
    ich habe noch eine andere Frage. Diese passt noch gut zu dieser Threadüberschrift. Ich möchte ein zweidimensionales Array an eine Funktion übergeben, die dann zu jedem Element 2 addiert und das Array dann wieder zurückgibt - wieder eine Rückgabe von einem Array. Das müsste eigentlich genauso gehene wie mit 1D Arrays, doch ich meine, dass man Zeiger auf Zeiger braucht. Stimmt das:

    ICh dachte an folgendes zur Übergabe:

    double** addtwo (double** arr)
{
 for(int i=0; i<6; i++)
   for(int j=0; j<6;j++)
    arr[i][j]+=2;
//Rückgabe des Arrays

 return arr;
}
//Es kommt ein initialisertes [6][6] Array names foo.

addtwo(foo); //Fehler: Konvertierung nicht möglich

    Wie funktioniert das denn bei zweidimensionalen Arrays. Liege ich mit meinen doppelten Zeigern falsch? WO liegt der Fehler bei der Übergabe?

    Bitte nicht meckern, dass ich es mit extra umständlich machen will 😃 😃

    Herzlichen Dank
    lg, freakC++

    0
  • H

    Die Lösung zu diesem Problem findet du hier: http://c-faq.com/aryptr/pass2dary.html . Da du offenbar versuchst Arrays und Pointer zu verstehen, wäre vermutlich das gesamte Kapitel 6 dieser FAQ eine schöne Lektüre.

    0
  • F

    Sagen wir so: Ich versuche sie wieder zu verstehen. Ich muss gründlich wiederholen. Die Logik hinter Zeigern (jedenfalls den einfachen ist mir klar). Ich lese mir das mal durch, wenn ich Zuhause bin. Jetzt fahre ich erstmal 45 min Auto und dann schau ich mal, ob jemand noch einen hilfreichen Post gemacht hat 😃 😃

    Ich danke euch!

    Bis dann
    lg, freakC++

    0
  • F

    Hallo zusammen,
    die 45 min zu rum 🙂 und ich habe mir die gepostete Seite durchgelesen und geschafft, was ich machen wollte: 2D Array als Parameter einer Funktion. Ich habe dennoch noch zwei Fragen. Mein Code sieht nun so aus:

    void foo(int (*ap)[6])	
{
  for (int i=0; i < SIZE; i++)
    for(int j=0; j < SIZE; j++)
      cout << ap[i][j];
}

    1.) Warum funktioniert diese Ausgabe? Woher weiß der Compiler, dass es sich um ein zweidimensionales Array handelt und was läuft intern ab?

    2.) Die eine Dimension ist beliebig groß, doch die zweite ist mit 6 festgelegt. Wenn diese nun auch beliebig groß sein soll bzw. unbekannt bei der Übergabe, wie muss die Funktion dann modifiziert werden? Ich dachte ursprünglich an folgendes, doch das ist anscheinend völliger Quatsch:

    void foo(int (*ap)*[]);

    Vielen Dank
    lg, freakC++

    0
  • ?

    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

    0
  • U

    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

    0
Anmelden zum Antworten