3. Array innerhalb einer Funktion erzeugen -> Rückgabe per Zeiger ?!

Array innerhalb einer Funktion erzeugen -> Rückgabe per Zeiger ?!

  • X

    Hallo Jungs und Mädels,

    ich hab hier eine (für mich recht) knifflige Frage 😉
    Und zwar geht es darum, dass ich gerne ein Array mittels Zufallsgenerator (100 Zeichen) füllen möchte und dieses dann anschließend ausgeben möchte.
    Der Haken daran ist jetzt, dass ganze soll in einer Funktion geschehen.

    Sprich, das Array soll in einer Funktion erzeugt und mittels Zufallszahlen (Integer) gefüllt werden.
    Dieses Array soll dann mittels Parameterliste zurückgegeben werden und anschließend mit einer Bubblesort sortiert werden.

    Die Funktionen sortieren (Bubblesort) und ausgeben habe ich bereits geschrieben und müssten lauffähig sein. Bisher klemmt es "nur" an diesem Array.

    Funktion sortieren:

    void sortieren (int n, int *z) //Funktionsdefinition
{

bool getauscht;
int i, temp;

do { 
getauscht=false;

for (i=0; i<n-1;i++)

if (z[i] >z[i+1])
{
temp=z[i];z[i]=z[i+1];
z[i+1]=temp; getauscht=true; 
}

} while(getauscht);

} //--- Ende Funktion sortieren ---

    Funktion ausgeben:

    void ausgeben(int n, int *z) //Funktionsdefinition
{

int i;

for (i=0; i<n;i++)
{
if(!(i % 20)) cout << endl;
cout<< setw(3)<< z[i];
}

} //--- Ende Funkton ausgeben ---

    Das Array zu erzeugen klappt ohne eine Funktion mit folgendem Code (Array + main():

    #include <iostream.h>
#include <iomanip.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>

void sortieren (int n, int *z); //Prototyp
void ausgabe (int n, int *z); //Prototyp

void main()
{

const int NMAX = 100;
int x[NMAX], i;

time_t timer;
srand((unsigned) time(&timer)); //Initialisierung

for (i=0; i< NMAX ; i++)
{
x[i]= rand() % 100;
}

cout<<"\nUnsortiertes Feld\n";

ausgeben(NMAX, x);

sortieren(NMAX, x);

cout<<"\n\nSortiertes Feld\n";

ausgeben (NMAX, x);

getch();

}

    Wie kann ich jetzt mein Array mit erfolgreicher Rückgabe in einer Funktion gestalten? Da muss ich doch irgendwie mit Pointer auf Pointer arbeiten? Oder etwa nicht?

    Über Ideen würde ich mich sehr freuen!

    Gruß xAmp

    0
  • D

    Ja, Doppelpointer wäre da eine Lösung.

    0
  • S

    std::vector eine andere (und bessere).
    Da man sich durch einen vector ebenso durchnavigieren kann wie durch ein Array, gibt's auch mit den anderen Funktionen kein Problem (wobei die natürlich besser ebenfalls vector-Referenzen übernehmen).

    Gruß,

    Simon2.

    0
  • A

    drakon schrieb:

    Ja, Doppelpointer wäre da eine Lösung.

    Und wenn es den wirklich mit einen Array gemacht werden muss, gibt es IMHO eine bessere Lösung als einen Doppelpointer (zumindestens von der Bedienung):

    Ich ziehe "void foo(typ*&)" dem "void foo(typ**)" vor...

    cu André

    0
  • P

    und ganz nebenbei noch was zu deinem Code: du lernst offenbar mit einem Buch das im letzten Jahrtausend schon etwas aelter war (oder dein Lehrer der dir C++ beibringt ist noch auf dem Stand von vor 20 Jahren):

    - es heisst in C++ int main() statt void main()
    - die meisten header mit .h sind veraltet. Nutze z.B. <iostream>, <iomanip>, <cstdlib>, <ctime>. Deren inhalte liegen dann allerdings im namespace std

    0
  • X

    Ahm jo, mein Lehrer steht kurz vor der Pensionierung und daher lern ich wohl noch von der alten Schule. 🙄

    Hat mir jemand ein Tutorial wie das genau mit Pointer auf Pointer gehen soll? Oder einen kurzen Ansatz mit dem ich mich dann beschäftigen könnte?

    0
  • *

    Sieht nach bubblesort aus, richtig?

    void bubble_sort(int*& arr, const std::size_t size)
{
    bool changes(false);

    do {
        changes = false;

        for (std::size_t i(0); i < (size - 1); ++i)
        {
            if (arr[i] > arr[i + 1])
            {
                // swap items
                int tmp(arr[i]); 
                arr[i] = arr[i+1];
                arr[i + 1] = tmp;
                // run again
                changes = true;
            }
        }
    } while (changes == true);
}

    ... so dann kannst du das was man swappen nennt auch durch std::swap ersetzen und sparst dir nen bissel was an code. Sonst aber soweit korrekt, nur nochmal die Variablen angepasst.

    #include <iomanip>

void show_array(const std::size_t size, const int* arr, const std::size_t width, std::ostream& out)
{
    for (std::size_t i(0); i < size; ++i)
        out << (i % 20 == 0 ? "\n" : "") << std::setw(width) << arr[i];
}

    So kannst du die Funktion auch wiederverwenden!

    #include <iostream> // std::cin, std::cout
#include <cstdlib> // std::srand, std::rand
#include <ctime> // std::time
#include <iomanip> // std::setw

void bubble_sort(int*&, const std::size_t);
void show_array(const int* arr, const std::size_t size, const std::size_t width = 3, std::ostream& out = std::cout)

const std::size_t count_items(100U);

int main()
{
    // std::rand initialisieren
    std::srand(static_cast<unsigned>(std::time(NULL)));

    int data[count_items];

    for (std::size_t i(0); i < count_items; ++i)
        data[i] = std::rand();

    // show data
    std::cout << "Unsortierter Array: " << std::endl;
    show_array(data, count_items);
    // sort data
    bubble_sort(data, count_items);
    // show data
    std::cout<<"\n\nSortierter Array: " << std::endl;
    show_array(data, count_items);

    // Auf Benutzereingabe warten ...
    std::cin.get();
}

void show_array(const int* arr, const std::size_t size, const std::size_t width, std::ostream& out)
{
    for (std::size_t i(0); i < size; ++i)
        out << (i % 20 == 0 ? "\n" : "") << std::setw(width) << arr[i];
}

void bubble_sort(int*& arr, const std::size_t size)
{
    bool changes(false);

    do {
        changes = false;

        for (std::size_t i(0); i < (size - 1); ++i)
        {
            if (arr[i] > arr[i + 1])
            {
                // swap items
                int tmp(arr[i]); 
                arr[i] = arr[i+1];
                arr[i + 1] = tmp;
                // run again
                changes = true;
            }
        }
    } while (changes == true);
}

    So ist es doch ordentlich 😉

    0
  • X

    uiuiui vielen vielen Dank!
    Durch deinen Code muss ich mich jetzt erst mal durchkämpfen. Da hat es für mich ein paar Neuerungen drin. 🙂

    Danke!

    0
  • A

    pumuckl schrieb:

    - die meisten header mit .h sind veraltet. Nutze z.B. <iostream>, <iomanip>, <cstdlib>, <ctime>. Deren inhalte liegen dann allerdings im namespace std

    Warum eigentlich veraltet? Ungültig wäre hier wohl die richtigere Wortwahl.

    0
  • S

    Artchi schrieb:

    pumuckl schrieb:

    - die meisten header mit .h sind veraltet. Nutze z.B. <iostream>, <iomanip>, <cstdlib>, <ctime>. Deren inhalte liegen dann allerdings im namespace std

    Warum eigentlich veraltet? Ungültig wäre hier wohl die richtigere Wortwahl.

    Auf der binären "gültig/ungültig"-Skala stimmt das natürlich. 😃

    Gruß,

    Simon2.

    0
  • X

    Hi (D)Evil,
    ich bin gerade dabei deinen Code zu testen. Jedoch bekomme ich einige Fehler von meinem Compiler geliefert. Einige wiederum konnte ich beseitigen aber das waren dann nur so Kleinigkeiten wie fehlende ';'.

    Folgende Beschwerden hat mein Compiler:

    In function int main()': Zeile 25: invalid initialization of non-const reference of type 'int*&' from a temporary of type 'int*' Zeile 6: in passing argument 1 ofvoid bubble_sort(int*&, size_t)'
    [Build Error] [main.o] Error 1

    Was ich ebenfalls nicht ganz nachvollziehen kann, ist z.B. die Angabe bubble_sort(int&*, size_t). Hier greift ja ein Integerwert auf die Adresse und auf den Datensatz zu? Oder wie hab ich das zu verstehen?

    Zudem füllst du das Array data[i] in der main(). Nur wie bekomme ich diesen Schritt ebenfalls in eine Funktion?

    Gruß xAmp

    0
Anmelden zum Antworten