3. Aufgabe Verwaltung eines dynamischen Arrays

Aufgabe Verwaltung eines dynamischen Arrays

  • *

    @Tyrdal sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Weil C++ ursprünglich von C mit Klassen kommt. Und zu der Zeit gab es noch kein std::string/vector.

    C with Classes ist deutlich älter (1979, ab 1985 wird die Sprache C++ genannt). cfront 2.0 (1989), das korrespondiert mit der zweiten Auflage von Stroustrups Buch, unterstützte schon fast alles aus dem Sprachstandard von C++98, aber eben noch keine STL als der Teil der Sprache. Stepanov und Lee hatten die als eigenes Projekt entwickelt, und nur das heißt eigentlich STL. Was sich wiederum auf ein Ada83 Projekt von Grady Booch (Booch Components) zurückführen lässt. Mit C++98 kommt zwar die STL als Teil der Standardlibrary, aber bis das alles korrekt umgesetzt worden war, gingen noch einige Jahre ins Land. Der auto_ptr aus C++98 war komplett unbrauchbar, so dass man warten musste bis das Boost Projekt den shared_ptr entwickelt hatte. Ohne jetzt nachzuschauen wann das war, es dürfte nach 2000 der Fall gewesen sein. Die funktionierenden Smart Pointer sind erst seit C++11 Teil der Sprache.

    Ich weiß nicht, was das bringen soll, hier immer darauf zu insistieren, dass der in den Aufgaben genutzt C++ Stil hoffnungslos veraltet ist. Ja ist er, aber das bringt die Studenten der Lösung nicht näher.

    @DirkB sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    @john-0 sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Dir ist hoffentlich bewusst, dass es eine Zeit gab, in der die STL noch nicht existierte?

    Da haben die Dozenten noch ihre FORTRAN-Script an C++ angepasst.

    Wenn das so alt wäre, gäbe es da keine dynamische Speicherverwaltung, das kam erst mit Fortran 90. Und ich durfte mich innerhalb des letzten Jahrzehnts mit Sprachmitteln aus Fortran 66 herumschlagen (das betreffende Feature wurde bereits in Fortran 77 als veraltet gekennzeichnet), weil der Autor des Programms sein Programm nicht an neuere Versionen angepasst hat. Zur Ehrenrettung des Autoren: Lange Zeit gab es nur g77 und kein gfortran, so dass im akademischen Umfeld weiterhin tapfer Fortran 77 geschrieben wurde. Da der Code für die Forschung verwendet wurde, war das erheblich einschneidender als eine Übungsaufgabe mit veraltetem Stil.

    @Tyrdal sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    SeppJ hat völlig recht. Warum sollte man heutzutage den Stand von 1983 als Grundlagen lehren?

    Es geht nicht darum C++ zu lernen, es geht darum die manuelle Speicherverwaltung kennen gelernt zu haben. Das ist das Lernziel, und C++ ist da nur Mittel zum Zweck. Wenn hier also endlose Diskussionen über die ach so schlechten Uni Aufgaben erfolgen, geht das vollkommen am Thema vorbei.

    1
    T
     1 Antwort
  • T

    @john-0 sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Ich weiß nicht, was das bringen soll, hier immer darauf zu insistieren, dass der in den Aufgaben genutzt C++ Stil hoffnungslos veraltet ist. Ja ist er, aber das bringt die Studenten der Lösung nicht näher.

    Aber dem sinnvollen Gebrauch von C++.

    Es geht nicht darum C++ zu lernen, es geht darum die manuelle Speicherverwaltung kennen gelernt zu haben. Das ist das Lernziel, und C++ ist da nur Mittel zum Zweck.

    Warum dann nicht in einer Sprache, die dies auch erfordert, C zum Bleistift? Oder wenn C++, warum dann nicht in Verbindung mit RAII?

    0
    *
    S
     2 Antworten
  • *

    @Tyrdal sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Warum dann nicht in einer Sprache, die dies auch erfordert, C zum Bleistift? Oder wenn C++, warum dann nicht in Verbindung mit RAII?

    Wenn Du da etwas erreichen willst, schreib die Professoren an. Nur habe ich da meine Zweifel, dass sie darauf reagieren werden.

    0
  • *

    @nobrainer sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Im main sage ich:

    int* arr = NULL;

    Ich habe die Funktion arrayAnlegen so geschrieben:

    int* arrayAnlegen(int len) 
{

    int neu;
    cout << "Gewuenschte Anzahl der Datenelemente: ";
    cin >> neu;
    int* arr = new int [neu];
    len = neu;
    return arr;
    }

    Du solltest in der Funktion arrayAnlegen prüfen, ob die Zeigervariable bereits einen Zeiger zugewiesen worden ist. Dazu soll es keine globalen Variablen geben. D.h. Dein arr muss an die Funktion zum Überprüfen übergeben werden.

    So langsam steige ich nicht mehr durch bei diesen Aufgaben.
    Leider stellt der Lehrer keine Musterlösung zum anschauen und nachvollziehen bereit.

    Was sind die konkreten Probleme, und was wird nicht verstanden?

    0
  • S

    @Tyrdal sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    @john-0 sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Es geht nicht darum C++ zu lernen, es geht darum die manuelle Speicherverwaltung kennen gelernt zu haben. Das ist das Lernziel, und C++ ist da nur Mittel zum Zweck.

    Oder wenn C++, warum dann nicht in Verbindung mit RAII?

    Woher willst du wissen, dass der Lehrer das nicht als nächsten Schritt geplant hat? Und danach die Einführung von Smartpointer? Man muss ja nicht ewig mit C++98 rumhantieren, aber ich persönlich finde das sinnvoll C++ 98, das immer noch in vielen Projekten verbreitet ist(!), zumindest mal kurz kennengelernt zu haben. Dann zeigt man, wie es besser geht und man versteht den Sinn und Zweck des Ganzen. So komplex ist das doch nicht, dass man das niemanden zumuten kann. Jeder von uns hat so schließlich ebenfalls angefangen.
    Und stell dir mal vor du fängst bei Oracle an und hantierst an der Datenbank rum: Glaubst du im ernst du findest dort keinen Legacy Code? Ich kann dir sogar Open Source Projekte zeigen, die noch mit selbstgebastelten Smart-Pointern arbeiten.

    0
    T
     2 Antworten
  • Mod

    @Steffo sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    @Tyrdal sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    @john-0 sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Es geht nicht darum C++ zu lernen, es geht darum die manuelle Speicherverwaltung kennen gelernt zu haben. Das ist das Lernziel, und C++ ist da nur Mittel zum Zweck.

    Oder wenn C++, warum dann nicht in Verbindung mit RAII?

    Woher willst du wissen, dass der Lehrer das nicht als nächsten Schritt geplant hat?

    Erfahrung. Wäre nämlich der erste Fall.

    0

  • Von der Aufgabenstellung, wie sie der TO beschrieben hat und ohne jeden Code, würde ich erwarten, man macht gerade Schleifen und switch-case.
    Und da passt eine dynamische Speicherverwaltung doch gar nicht rein. Bei diesem Kenntnisstand dürfte man nicht mal wissen, was damit überhaupt gemeint ist.
    Andersrum, wäre man soweit für solche selbst geschriebenen Arrays, hätte man die Aufgabenstellung, nur ohne diesen Punkt, doch schon gelöst und hätte auch entsprechenden Code.

    Hier ist ja nichts. Da kann man doch nur spekulieren.

    0

  • Vieleicht habe ich mich auch nur verannt, aber was ich meine;
    bevor man sein eigenes Array hat, kann man ja schon mal das Menu schreiben. Als Array benutzt man erst man einen vector<T>. Nur als Platzfüller über eine using- Direktive zB. Ich bin auch der Meinung, das std::vectorGrundlage ist.

    Später kann man dann sein eigenes Array einfügen.

    0
  • T

    @Steffo sagte in Aufgabe Verwaltung eines dynamischen Arrays:

    Und stell dir mal vor du fängst bei Oracle an und hantierst an der Datenbank rum: Glaubst du im ernst du findest dort keinen Legacy Code? Ich kann dir sogar Open Source Projekte zeigen, die noch mit selbstgebastelten Smart-Pointern arbeiten.

    Meinst du ernsthaft Legacy Oracle Code wäre was für Anfänger? Ne, erstmal richtig lernen und danach die Altlasten wenn nötig.

    0

  • @nobrainer ,
    in der main so wie in den meisten Funktionen brauchst Du eine Abfrage:

    //-----------------------------------------------------------------------------
int askUser( std::string output, int min, int max )
{
  int retVal = -1;

  if ( min >= max )
  {
    std::cout << "min muss kleiner max sein" << "\n";
  }
  else
  {
    do
    {
      std::cout << output << "\n";
      std::cout << "Eingabe:";
      std::cin >> retVal;
      if ( retVal < min || retVal > max )
      {
        std::cout << "Eingabe nicht im Eingabebereich" << "\n";
      }
    } while ( retVal < min || retVal > max );
  }
  return retVal;
}

    Die kann schon mal in der main in einer do-while-schleife genutzt werden:

      int           input = 0;
  std::size_t   mainArraySize = 0;
  int         * mainArray = nullptr;

  do
  {
    input = askUser( "1 Array anlegen\n2 Array-Groesse aendern\n3 Wert eingeben\n4 Feld ausgeben\n0 Programm beenden\n", 0, 4 );

    switch ( input )
    {
      case 1:
        mainArray = arrayAnlegen( mainArray, mainArraySize );
        break;

      case 2:
        mainArray = arrayGroesseAendern( mainArray, mainArraySize );
        break;

      case 4:
        arrayAusgeben( mainArray, mainArraySize );
        break;

      default:
        break;
    }
  } while ( input != 0 );
  if ( mainArray ) delete[] mainArray; // nur der Ordnung halber
  return 0;

    jetzt noch eine Funktion:

    int * arrayAnlegen( int * mainArray, std::size_t & mainArraySize )
{
  int * localArray = mainArray;

  if ( ! localArray )
  {
    mainArraySize = askUser( "Groesse des Arrays?", 2, 1000 );
    if ( mainArraySize > 0 )
    {
      localArray = new int[mainArraySize];
      for ( std::size_t i = 0; i < mainArraySize; ++i )
      {
        localArray[i] = -1;
      }
    }
  }
  else
  {
    std::cout << "Fehler: Array schon vorhanden" << "\n";
  }
  return localArray;
}

    u.s.w.

    Ungetestet und geht wahrscheinlich noch eleganter😉

    0
Anmelden zum Antworten