[Hell yeah!]

Und natürlich auch noch mit ihnen arbeiten.

Gibt es eine Möglichkeit derartiges in C++ umzusetzen?

Möglichst in Form dessen, dass der Anwender dazu aufgefordert wird, eine beliebige Anzahl an Variablen vorzugeben, welche anschließend alle - versehen mit einer fortlaufenden Nummer - kreiert, durch den Benutzer mit Werten versehen und im Anschluss sortiert werden.

Meine Überlegungen scheitern immer wieder an genau dieser Unmöglichkeit, aus einer Variable mehrere, theoretische Variablen zu erschaffen und diese dann eben auch noch mit einem Wert zu versehen.

[Pyrokar]

Um eine unbekannte Anzahl an Eingaben zu speichern, reicht eine Variable aus.
Diese sollte ein Container sein, die mehrere Werte aufnehmen kann.
Dazu könnte man bspw. verwenden: Array, Liste oder Vektor. Was sich wie eignet und benutzen lässt, weiß ich nicht, mit C++ habe ich bisher nicht viel zu tun gehabt.

[Thoronador]

Gibt es eine Möglichkeit derartiges in C++ umzusetzen?

Ja.

Meine Überlegungen scheitern immer wieder an genau dieser Unmöglichkeit, aus einer Variable mehrere, theoretische Variablen zu erschaffen und diese dann eben auch noch mit einem Wert zu versehen.

Das ist auch unsinnig. Wenn du z.B. zehn Variablen haben möchtest, dann erschaffe auch zehn Stück und nicht eine. Die gängigste Möglichkeit in diesem Fall ist wohl ein dynamischer Array (Feld), für welchen man den Speicher entsprechend der gewünschten Anzahl an Variablen allokiert. In einem Array greift man dann über einen Index auf das jeweils gewünschte Element zu - damit hast du dann auch gleich deine fortlaufende Nummer. Nur muss man in diesem Fall aufpassen, dass man auch genug Speicher für alle Elemente zuweist und nicht bei einem Feld mit nur 10 Elementen plötzlich aufs elfte Element zugreifen will. Freigeben muss man den Speicher vor Programmende auch wieder.
Sortieren ließe sich dann durch Vertauschen der Werte an den verschiedenen Indices.

Wenn man sich die Sache mit dem Speichermanagement sparen will, kann man auch einen geeigneten STL-Container nutzen, z.B. std::vector. Das kommt einem klassischen Array recht nahe.
Mit std::vector könnte die Eingabe von Integerwerten beispielsweise so aussehen:

#include <iostream>
#include <vector>

int main()
{
  std::vector<int> Werte; //Vektor für die Aufnahme von Integerwerten
  int Eingabe = 0;
  do
  {
    std::cout << "Geben Sie eine weitere, ganze Zahl ein (Eingabe von 0 beendet die Eingabephase).\n";
    std::cin >> Eingabe;
    if (Eingabe!=0) Werte.push_back(Eingabe);
  } while (Eingabe!=0);

  std::cout << "Es wurden ingesamt "<<Werte.size()<<" Werte eingegeben.\n";
  //Die folgende Schleife gibt nochmals alle eingegebenen Werte aus.
  unsigned int i;
  for (i=0; i<Werte.size(); ++i)
  {
    //Werte.at(i) greift auf das i. Element im Vektor zu.
    //Die Zählung beginnt bei 0. Wurden also zehn Werte eingelesen,
    // so läuft i von 0 bis 9, nicht von 1 bis 10.
    std::cout << Werte.at(i) << "\n";
  }

  //Hier kommt dann die Verarbeitung wie z.B. Sortieren.

  return 0;
}

[Hell yeah!]

Super, danke.

Mit Arrays habe ich mich bisher noch garnicht beschäftigt ... das werde ich jetzt wohl mal angehen.

[Hell yeah!]

So, ich habe mittlerweile mal etwas auf die Beine gestellt, von dem ich der Meinung bin, dass es soweit funktionieren sollte.
Allerdings erwartet der Compiler von mir, in der letzten Zeile (Ende des main()-Rumpfes), allerhand Dinge, die ich nicht so recht zu interpretieren vermag.

Programm:

Spoiler:(zum lesen bitte Text markieren)

#include <iostream.h>
using namespace std;

int main()
{
    int Variablenanzahl;

    do
    {
    cout << "Wieviele Zahlen moechten sie ordnen lassen?\n";
    cin >> Variablenanzahl;
    
    int Array[Variablenanzahl];
    int Counter = 0;
    
    if (Variablenanzahl > 1)
    {                                      
                        while (Counter < Variablenanzahl)
                        {
                        cout << "Bitte geben sie den Wert für Variable " << Counter << " ein!\n";
                        cin >> Array[Counter];
                        Counter++;
                        }
    }
    else
    cout << "Es werden mindestens zwei Zahlen benoetigt um sie ordnen zu lassen.\n";

for (Counter = 0; Counter < Variablenanzahl; Counter++)
{
    int Zwischenspeicher;
    int Counter2 = Counter;
    
    while (Counter2 < Variablenanzahl)
    {
          Counter2++;
          if (Array[Counter + Counter2] < Array[Counter2])
          {
                             Zwischenspeicher = Array[Counter2];
                             Array[Counter2] = Array[Counter + Counter2];
                             Array[Counter + Counter2] = Zwischenspeicher;
                             }
          }
}

Counter = 0;
while (Counter < Variablenanzahl)
                        {
                        cout << Array[Counter] << "\n";
                        Counter++;
                        }
}

Syntaxanalyse:

Spoiler:(zum lesen bitte Text markieren)

expected `while' at end of input
expected `(' at end of input 
expected primary-expression at end of input 
expected `)' at end of input
expected `;' at end of input
expected `}' at end of input

[Delta 38]

nach einer do anweisung muss eine while bedingung folgen.

#include <iostream.h>
using namespace std;

int main()
{
    int Variablenanzahl;

    do
    {
    cout << "Wieviele Zahlen moechten sie ordnen lassen?\n";
    cin >> Variablenanzahl;
    
    int Array[Variablenanzahl];
    int Counter = 0;
    
    if (Variablenanzahl > 1)
    {                                      
                        while (Counter < Variablenanzahl)
                        {
                        cout << "Bitte geben sie den Wert für Variable " << Counter << " ein!\n";
                        cin >> Array[Counter];
                        Counter++;
                        }
    }
    else
    cout << "Es werden mindestens zwei Zahlen benoetigt um sie ordnen zu lassen.\n";

for (Counter = 0; Counter < Variablenanzahl; Counter++)
{
    int Zwischenspeicher;
    int Counter2 = Counter;
    
    while (Counter2 < Variablenanzahl)
    {
          Counter2++;
          if (Array[Counter + Counter2] < Array[Counter2])
          {
                             Zwischenspeicher = Array[Counter2];
                             Array[Counter2] = Array[Counter + Counter2];
                             Array[Counter + Counter2] = Zwischenspeicher;
                             }
          }
}

Counter = 0;
while (Counter < Variablenanzahl)
                        {
                        cout << Array[Counter] << "\n";
                        Counter++;
                        }
}while(BEDINGUNG);
}

EDIT: Warum tust du den Code in einen Spoiler? Der Übersicht halber?

[Hell yeah!]

Was würde ich nur ohne dieses Subforum machen? ^^

... jetzt fällt mir auch wieder ein warum ich das do dahin gesetzt hatte.


Allerdings zeigt sich eben das mein Bubblesortalgorithmus nicht korrekt funktioniert. -.-

EDIT: Warum tust du den Code in einen Spoiler? Der Übersicht halber?

Jupp.

[Thoronador]

Allerdings zeigt sich eben das mein Bubblesortalgorithmus nicht korrekt funktioniert. -.-

Mehr noch: Du müsstest theoretisch sogar eine Memory Access Violation mit Programmabsturz bekommen, weil beim bisherigen Code auf Indexbereiche zugegriffen wird, die nicht mehr zum Array gehören.

Betrachten wir mal den entsprechenden Code. (Dass es kein richtiger Bubblesort ist, will ich hier mal gar nicht monieren.)

for (Counter = 0; Counter < Variablenanzahl; Counter++)
{
    int Zwischenspeicher;
    int Counter2 = Counter;
    
    while (Counter2 < Variablenanzahl)
    {
          Counter2++;
          if (Array[Counter + Counter2] < Array[Counter2])
          {
                             Zwischenspeicher = Array[Counter2];
                             Array[Counter2] = Array[Counter + Counter2];
                             Array[Counter + Counter2] = Zwischenspeicher;
          }
    }
}

Variablenanzahl enthält die Anzahl der Elemente im Array, d.h. der Index im Array läuft von 0 bis Variablenanzahl-1. Mit der Bedingung der for-Schleife wird zwar sichergestellt, dass Counter immer in diesem Bereich ist, aber Counter2 ist es nicht. Dazu kommt, dass du den Index stellenweise als Counter2 plus(!) Counter2 berechnest, also im Extremfall (wenn das Programm nicht vorher abbricht) auf einen Bereich zugegriffen wird, der in etwa doppelt so groß ist wie der eigentliche Array es hergibt. Was in dem Bereich steht, der nicht zum Array gehört, kann man nicht sagen, bestenfalls steht da irgendwelcher zufälliger Müll drin. Schlimmstenfalls schreibst du damit in andere Speicherbereiche, in die du eigentlich gar nichts schreiben willst, mit dem Ergebnis, dass Programme, die (berechtigterweise) auf diesen Bereich zugreifen wollen, irgendwelche für sie völlig unpassenden Daten lesen.

Zu einem der Fehler:
Vor der while-Schleife wird Counter2 auf den Wert von Counter gesetzt. Im letzten Durchlauf ist das der Wert des höchsten, zulässigen Arrayindex, also Variablenanzahl-1. Dann wird aber in der ersten Zeile innerhalb der while-Schleife, gleich Counter2 um eins erhöht, womit der Zugriff auf Array[Counter2] schon auf einen Index geht, der nicht mehr zum Array gehört, sondern "dahinter" liegt. Dass Array[Counter + Counter2] dann erst recht einen solchen erwischt, ist klar, hier ist der Index ja durch die Addition noch höher.

Angenommen, dein Array hat 10 Elemente, d.h. der höchste Index ist 9, dann ist im ersten Durchlauf der Schleife Counter==0, und irgendwann zum letzten Durchlauf der while-Schleife wird Counter2==10 erreichen. In dem Moment, wo die Bedingung der while-Schleife, also (Counter2 < Variablenanzahl), überprüft wird, ist Counter2 noch auf 9, aber er wird gleich danach auf 10 erhöht. Schlecht, damit wird's ein ungültiger Index. In nächsten Durchläufen der for-Schleife werden schon die letzten zwei Durchgänge der while-Schleife auf einen ungültigen Index zugreifen, im nächsten Durchlauf der for-Schleife werden es drei sein, und so geht das weiter.

Um das zu beheben, würde ich dir vorschlagen, erstens die while- durch eine weitere for-Schleife zu ersetzen. (Man kann Schleifen auch verschachteln.) Zweitens solltest du die Sache mit den Indices beheben, indem du die Addition da rausnimmst und einfach nur auf Indices mit Counter und Counter2 zugreifst und die vergleichst.

Das müsste dann in etwa so aussehen:

int i, j, Zwischenspeicher;
for (i=0; i<Variablenanzahl; ++i)
{
  for (j=i+1; j<Variablenanzahl; ++j)
  {
    if (Array[i]<Array[j])
    {
      Zwischenspeicher = Array[i];
      Array[i] = Array[j];
      Array[j] = Zwischenspeicher;
    }//if
  } //for j
}//for i

[Hell yeah!]

Ich hab' das ganze mittlerweile überarbeitet, doch egal wie ich den Code gestalte, ich bekomme immer nur Mist heraus (in vorhergehenden Versionen sogar Zahlen die ich nicht eingegeben habe oder identische Zahlen ... aber auf jeden Fall immer eine zu viel und weitestgehend unsortiert).

Aktuell sieht mein Bubblesort-Versuch folgendermaßen aus:

    int Zwischenspeicher;
    int Counter2 = 0;
    
for (Counter = 0; Counter < Variablenanzahl -1; Counter++)
{
    Counter2 = 0;
    for (; Counter2 < Variablenanzahl -1; Counter2++)
    {
          if (Array[Counter2] > Array[Counter2 +1])
          {
                             Zwischenspeicher = Array[Counter2 +1];
                             Array[Counter2 +1] = Array[Counter2];
                             Array[Counter2] = Zwischenspeicher;
                             }
          }
}

Counter2 = 0 konnte ich leider nicht in die zweite For-Schleife setzten, da an dieser Position mein Kompiler eine, für mich, unnachvollziehbare Fehlermeldung ausgegeben hat.

[Delta 38]

Counter2 = 0 konnte ich leider nicht in die zweite For-Schleife setzten, da an dieser Position mein Kompiler eine, für mich, unnachvollziehbare Fehlermeldung ausgegeben hat.

nämlich welche?

[Hell yeah!]

Kurios, auf einmal akzeptiert er es in dieser Position.
Vielleicht lag der Fehler doch wo anders ...

Nichtsdestodem hackt die Sortierung immer noch gewaltig.

[Delta 38]

mal eine andere Frage: warum Bubblesort? ich meine von der Performance her ist dieser Sortieralgorithmus nicht mehr auf dem aktuellen stand
Naja, ich schau mal wegen deinem problem

EDIT: Bei mir funktionierts

Spoiler:(zum lesen bitte Text markieren)

//*************
//    Bubblesort
//*************

#include <iostream> 

using namespace std;

int main()
{
         int list[5] = {11,25,33,48,9};  // unsortierte liste
         int n = 5;                              // anzahl an elementen
         
         int buffer;                // Zwischenspeicher
         
        // Ausgabe 
         cout << "Unsorted List" << endl;
         for(int k = 0; k < n; k++)
         {
                 cout << list[k] << " ";
         }
         cout << endl << "----" << endl;
         
       // Sortieren
         for(int i = 0; i < n -1; i++) // solange i kleiner als 4 ist
         {
              for(int j = 0;j < n-1; j++) // solange j kleiner als 4 ist
              {
                      if(list[j] > list[j+1])  // wenn das linke element größer ist:
                      {
                                // vertauschen
                                 buffer = list[j+1];
                                 list[j+1] = list[j];
                                 list[j] = buffer; 
                      }       
              }
         }
         
// Ausgabe
         cout << "Sorted List" << endl;
         for(int k = 0; k < n; k++)
         {
                 cout << list[k] << " ";
         }
         cout << endl << "----" << endl;
         cin.get();
         return 0;
}

[Thoronador]

Aktuell sieht mein Bubblesort-Versuch folgendermaßen aus:

    int Zwischenspeicher;
    int Counter2 = 0;
    
for (Counter = 0; Counter < Variablenanzahl -1; Counter++)
{
    Counter2 = 0;
    for (; Counter2 < Variablenanzahl -1; Counter2++)
    {
          if (Array[Counter2] > Array[Counter2 +1])
          {
                             Zwischenspeicher = Array[Counter2 +1];
                             Array[Counter2 +1] = Array[Counter2];
                             Array[Counter2] = Zwischenspeicher;
                             }
          }
}

Counter2 = 0 konnte ich leider nicht in die zweite For-Schleife setzten, da an dieser Position mein Kompiler eine, für mich, unnachvollziehbare Fehlermeldung ausgegeben hat.

Der Code funktioniert bei mir einwandfrei. Das gilt sowohl wenn man Array als std::vector<int> deklariert als auch als normales Feld, z.B. als int array[5]. Vorausgesetzt, Variablenanzahl enthält immer noch die Anzahl der Elemente.

mal eine andere Frage: warum Bubblesort? ich meine von der Performance her ist dieser Sortieralgorithmus nicht mehr auf dem aktuellen stand

Natürlich ist Bubblesort "auf dem aktuellen Stand", es ist nur nicht der schnellste Algorithmus. Aber darum geht's auch gar nicht. Wenn dein Array plötzlich Werte anzeigt, die er gar nicht beinhalten sollte, dann hättest du auch besseres zu tun, als dir um die Komplexität deines Sortierverfahrens Gedanken zu machen.

[Delta 38]

Natürlich ist Bubblesort "auf dem aktuellen Stand", es ist nur nicht der schnellste Algorithmus. Aber darum geht's auch gar nicht. Wenn dein Array plötzlich Werte anzeigt, die er gar nicht beinhalten sollte, dann hättest du auch besseres zu tun, als dir um die Komplexität deines Sortierverfahrens Gedanken zu machen.

mit auf dem aktuellsten Stand meinte ich doch von der performance, also der schnelligkeit her. War ja auch nicht bös gemeint Ja wie ich schon sagte, bei mir funktioniert er auch.

[Hell yeah!]

Das Problem mit der falschen Sortierung konnte ich mittlerweile durch die neue Position von Counter 2 = 0 beheben (auch wenn ich nicht verstehe, warum es in der vorhergehenden Variante bei euch aber nicht bei mir funktionierte), dennoch wird mir immernoch die größte Zahl, nach dem Sortieren, doppelt angezeigt - und zwar einmal am Anfang und einmal am Ende.

Ich bin mal so frei und gebe euch den ganzen Code zur Analyse durch.

Spoiler:(zum lesen bitte Text markieren)

#include <iostream.h>
using namespace std;

int main()
{
    int Variablenanzahl = 0;

    do
    {
    cout << "Wieviele Zahlen moechten sie ordnen lassen?\n";
    cin >> Variablenanzahl;
    
    int Array[Variablenanzahl];
    int Counter = 0;
    
    if (Variablenanzahl > 1)
    {                                      
                        while (Counter < Variablenanzahl)
                        {
                        cout << "Bitte geben sie den Wert fuer Variable " << Counter << " ein!\n";
                        cin >> Array[Counter];
                        Counter++;
                        }
    }
    else
    cout << "Es werden mindestens zwei Zahlen benoetigt um sie ordnen zu lassen.\n";

    int Zwischenspeicher;
    int Counter2;
    
for (Counter = 0; Counter < Variablenanzahl -1; Counter++) //Counter zur Ressourcenschonung wiederverwendet
{
    for (Counter2 = 0; Counter2 < Variablenanzahl -1; Counter2++)
    {
          if (Array[Counter2] > Array[Counter2 +1])
          {
                             Zwischenspeicher = Array[Counter2 +1];
                             Array[Counter2 +1] = Array[Counter2];
                             Array[Counter2] = Zwischenspeicher;
                             }
          }
}

Counter = 0;
while (Counter < Variablenanzahl)
                        {
                        cout << Array[Counter] << "\n";
                        Counter++;
                        }
cout << "\n";
} while (1); //nicht unbedingt notwendig, steht im Zusammenhang mit Zeile 5
}

Für Bubblesort habe ich mich deshalb entschieden, da dieser Algorithmus sehr simpel is' und ich mich das erste Mal mit Sortieralgorithmen beschäftige.

[Delta 38]

So, ich hab mir deinen Code kopiert und selbst compiliert, und bei mir sortiert er ohne die von dir gennanten Probleme Welchen Compiler benutzt du denn?

[Hell yeah!]

Bloodshed Dev C++

Allerdings muss ich, peinlich wie es auch sein mag, zugeben, dass der letzte Fehler vom Typ Fehler 40 war.

Dummerweise habe ich mich so sehr auf das Ergebnis konzentriert, dass ich nicht bemerkt habe, dass ich zwischen der Eingabe der letzten Variable und der Ausgabe der sortierten Zahlen keinen Abstandshalter eingefügt habe (\n), also sah die letzte Eingabe für mich auch immer wie die erste Ausgabe aus. [Bild: 003.gif]


Das Thema wäre also erledigt.
Ihr habt mir sehr geholfen, danke euch allen.

[Kiview]

Bloodshed Dev C++

Das ist nicht dein Compiler sondern deine IDE.

Du benutzt sicher MinGW oder Cygwin, die auf den gcc benutzen.

[Hell yeah!]

Das ist nicht dein Compiler sondern deine IDE.

Du benutzt sicher MinGW oder Cygwin, die auf den gcc benutzen.

Bloodshed nutzt MinGW um genau zu sein.