C++ Schleife for return

S1l3n7spy3r

Lt. Junior Grade
Registriert
Dez. 2008
Beiträge
256
Hallo zusammen,

ich stehe gerade vor folgendem Problem.

Ich versuche ein Programm mit Visual Studio 2013 zu schreiben.
Dieses Programm soll aus separaten unterprogrammen bestehen welche einige Funktionen übernehmen.

Hiermit will ich erreichen, dass das Hauptprogramm immer weiter gebaut werden kann, und nur auf die jeweilen Funktionen zurückgreift, wenn es diese braucht.

Leider ist derzeit mein allwissendes C++ Buch unterwegs und ich stehe etwas auf dem Schlauch.

Derzeit sieht es wie folgt aus:

Code:
#include <stdio.h>
#include <conio.h>
#define MAX 10


int i = 0, fehler = 0, x = 0, z[MAX], wert = 0;
int zahl()
{
	printf("Bitte geben Sie eine Zahl von 1 bis 100 ein:\n");
	scanf("%i", &wert);
	return wert;
}

int fehleingabe()
{
	if (wert <0 || wert >100)
	{
		printf("\n%i war ein falscher Wert!\n", wert);
		fehler = 1;
	}
	while (x < MAX ; x++)
	{
		if (z[x] == wert)
		{
			printf("\nDie Zahl %i war schon im Array vorhanden\n", wert);
			fehler = 1;
		}
		else
		{
			fehler = 0;
		}
	}
	return fehler;
}

void main()
{
	do
	{
		do
		{
			fehler = 0;
			zahl();
			fehleingabe();
		} while (fehler == 1);
		z[i] = wert;
		printf("Die Zahl %i ist %i", i+1, z[i]);
	} while (i < MAX , i++);
	_getch();
}

Leider habe ich das problem, dass das Programm immer aus den do while schleifen fliegt.

Kann mir jemand vielleicht hier den entscheidenden Tip geben?

Viele Grüße
Marvin
 
Die Bedingungen der while Schleifen sind nicht gleich, einmal hast du ein Komma geschrieben, das andere Mal ein Semikolon.
 
Zuletzt bearbeitet:
Und irgendwann musst du x wieder auf 0 zurücksetzen, sonst überprüft er nicht, ob die Zahl schon im Array vorhanden ist.
 
hallo

die äussere do/while schleife läuft nur 10 bzw 11 mal durch, die inner bricht laut deinem code sofort ab, sobald deine eingegebene zahl kleiner 0 oder größer 100 ist bzw im z-array bereits vorhanden ist.
jetzt kommt es einfach auf dein input an?

visual studio bietet recht nettes source code level debugging, einfach mal durchsteppen und schauen an welcher stelle das programm (unerwünscht) aussteigt.

in deinem code sind einige böse fouls drin, die meisten globalen variablen sind unnötig und bieten viel spielraum für potentielle fehler, lieber lokale variablen bzw funktionsparamter benutzen.
bei bekannter anzahl schleifendurchläufe keine while sondern for nutzen, die runtime parameter lokal definieren, set/reset etc.

grüße
wp
 
Ergaenzend zu dem, was meine Vorredner bereits gesagt haben: Ich seh da irgendwie nur C, kein C++. Viele Funktionen, die du verwendest, sind veraltet oder eben C (siehe printf und scanf). Ich kann dir z.B. http://www.learncpp.com/ als gutes Einsteiger-Tutorial fuer C++ empfehlen - da lernst du dann wirklich C++ und nicht bestenfalls so einen Hybriden aus C und C++ oder gar nur C. Es lohnt sich. :)

/Das X, den einzulesenden Wert und die Fehler-Variable global zu halten, ist kein guter Stil. Das sollte nur den Funktionen, die sie benoetigen, bekannt sein und moeglich sein, sie zu aendern.
 
Zuletzt bearbeitet:
Woa.. jetzt bin ich ein wenig schockiert soviele antworten in so kurzer Zeit .. :D
Vielen Dank!

aaronwillforum schrieb:
Und irgendwann musst du x wieder auf 0 zurücksetzen, sonst überprüft er nicht, ob die Zahl schon im Array vorhanden ist.

bei meinem Lehrer sah es irgendwie so aus:

Code:
while (x=0; x<10; x++)

jedoch hab ich da irgendwie das Gefühl, dass das nicht gehen kann, weil ja jedesmal auf 0 gesetzt wird oder etwa nicht?
 
Du moechtest ja einfach dein Array Element fuer Element durchgehen und schauen, ob der Wert schon drin ist.
1. Benutze statt eines einfachen Arrays einen sogenannten Vektor.
2. Benutze einen For-Each-Loop, saehe dann so aus:

Code:
std::vector<int> zahlen(MAX); //initialisiere den Vektor mit einer festen Anzahl an Elementen
zahlen.push_back(1); //1 hinzufuegen
zahlen.push_back(2); //2 hinzufuegen

for(auto zahl : zahlen) //fuer jede zahl in zahlen
{
  if(zahl == wert) std::cout << "Wert schon vorhanden!" << std::endl;
}

Zu deinem Beispiel: Mach x nicht global sondern tu das hier:
Code:
for(int i = 0; i < MAX; ++i)
{
//
}
Eine Zaehlvariable global zu halten ist keine gute Idee!
Warum du aus der Schleife fliegst:
Du machst in der Schleife eine Ueberpruefung, ob die Zahl vorhanden ist, wenn nein, gehst du in den Else-Block, in welchem du return 0; machst. Damit beendest du deine komplette Funktion beim ersten Schleifendurchlauf. Was du stattdessen moechtest, ist das Else wegzulassen, und ausserhalb der Schleife ein return 0 zu machen. Wenn du diesen Code-Teil erreichst, bedeutet das, dass die Zahl nicht gefunden wurde, also alles ok ist.
 
Zuletzt bearbeitet:
Kann es sein, dass du statt
Code:
while (x=0; x<10; x++)
folgendes meinst?
Code:
for (x = 0; x < 10; x++)
 
So wuerde das ohne den ganzen C-Krempel und die unueblichen Do-While-Schleifen aussehen:

Code:
#include <iostream>
#include <std>
#define MAX 10

int zahl()
{
  	int wert;
  	std::cout << "Bitte geben Sie eine Zahl von 1 bis 100 ein:" << std::endl;
  	std::cin >> wert;
	  return wert;
}

bool fehleingabe(int wert, std::vector<int>& zahlen)
{
	  if(wert < 1 || wert > 100)
	  {
		    std::cout << wert << " war ein falscher Wert" << std::endl;
		    return false;
	  }

	  for(auto zahl : zahlen)
	  {
		    if(zahl == wert)
		    {
			      std::cout << wert << " war ein falscher Wert!" << std::endl;
			      return false
		    }
  	}

  	return true;
}

void main()
{
  	bool richtige_eingabe = false;
	  std::vector<int> werte(MAX);

	  for(werte.size() < MAX)
	  {
		    int neuer_wert;

		    while(!richtige_eingabe)
		    {
			      neuer_wert = zahl();
      			richtige_eingabe = fehleingabe(neuer_wert, werte);
		    }

		    werte.push_back(neuer_wert);
		    std::cout << "Die Zahl " << werte.size() << " ist " << neuer_wert << std::endl;

		    richtige_eingabe = false;
	  }
}
Ergänzung ()

Etwas huebscher:

Code:
#include <algorithm>
#include <iostream>
#include <vector>

#define MAX 10

int get_number_from_input()
{
  int number;
  while (true)
  {
    std::cout << "Bitte geben Sie eine Zahl von 1 bis 100 ein: ";
    std::cin >> number;
    if (number >= 1 && number <= 100) break;
    std::cout << number << " war ein falscher Wert!" << std::endl;
  }
  return number;
}

int get_unique_number(std::vector<int>& zahlen)
{
  while (true)
  {
    int number = get_number_from_input();
    if (std::find(zahlen.begin(), zahlen.end(), number) == zahlen.end()) return number;
    std::cout << "Die Zahl " << number << " war schon im Array vorhanden." << std::endl;
  }
}

void main()
{
  std::vector<int> zahlen(MAX);
  std::generate(zahlen.begin(), zahlen.end(), [&](){ return get_unique_number(zahlen); } );
}
 
Zuletzt bearbeitet:
Das würde aber nicht funktionieren, wenn du Zahlen von 0 bis 100 erlaubst, da du immer den kompletten Vector durchsuchst, statt nur die ersten 0, 1, 2, ... Elemente. Die ints im Vector werden bei der Initialisierung auf 0 gesetzt. Du solltest noch einen Iterator i = zahlen.begin() definieren und ihn jedes Mal erhöhen. Und dann nur von begin bis i suchen in std::find().
 
Das stimmt schon, wenn man 0 erlaubt, was nach meinem Vertaendnis der Aufgabe aber nicht gefordert ist, dann funktioniert das so nicht richtig.

N kleiner Trick waere, den Vektor mit nem anderen Wert zu initialisieren:
std::vector<int> zahlen(MAX, -1) ;)
 
Zuletzt bearbeitet:
Noch hübscher wär's, wenn du aus void main int main machst, die an get_unique_number übergebene Referenz const machst und MAX von einem #define in eine Konstante änderst.
 
Hoppla, haste absolut recht. ;)
Ergänzung ()

So dann:

Code:
#include <algorithm>
#include <iostream>
#include <vector>

const int max = 10;

int number_from_input()
{
  int number;
  while (true)
  {
    std::cout << "Bitte geben Sie eine Zahl von 1 bis 100 ein: ";
    std::cin >> number;
    if (number >= 1 && number <= 100) break;
    std::cout << number << " war ein falscher Wert!" << std::endl;
  }
  return number;
}

int unique_number(const std::vector<int>& numbers)
{
  while (true)
  {
    int number = number_from_input();
    if (std::find(numbers.begin(), numbers.end(), number) == numbers.end()) return number;
    std::cout << "Die Zahl " << number << " war schon im Array vorhanden." << std::endl;
  }
}

int main()
{
  std::vector<int> numbers(max, -1);
  std::generate(numbers.begin(), numbers.end(), [&numbers](){ return unique_number(numbers); });
  return 0;
}

([url]http://pastebin.com/YpwaCegw)[/URL]
 
Zurück
Oben