Try catch wykonuje się kilka razy bez powodu

Question

Mam taką funkcję:

int x = NULL, y = NULL;
std::string temp;

void mojaFunckja(std::string alert)
{
	std::cout << alert << std::endl;

	if (NULL == x)
	{
		std::cout << "Podaj x: ";

		try
		{
			getline(std::cin, temp);
			x = std::stoi(temp);

			if (x <= 0)
			{
				x = NULL;
				throw std::logic_error("Wartosc musi byc >0");
			}
		}
		catch (std::invalid_argument) {
			mojaFunckja("Zla wartosc");
		}
		catch (std::logic_error e) {
			mojaFunckja( e.what() );
		}
		catch (std::exception e) {
			mojaFunckja("Blad: " + static_cast<std::string>(e.what()));
		}
		catch (...) {
			mojaFunckja("Nieznany blad");
		}
	}
	else {
		std::cout << "Podaj x: " << x << std::endl;
	}

	std::cout << "Podaj y: ";

	try
	{
		getline(std::cin, temp);
		y = std::stoi(temp);

		if (y <= 0)
		{
			y = NULL;
			throw std::logic_error("Wartosc musi byc >0");
		}
	}
	catch (std::invalid_argument) {
		mojaFunckja("Zla wartosc");
	}
	catch (std::logic_error e) {
		mojaFunckja(std::string(e.what()));
	}
	catch (std::exception e) {
		mojaFunckja("Blad: " + static_cast<std::string>(e.what()));
	}
	catch (...) {
		mojaFunckja("Nieznany blad!");
	}

	std::cout << y<<std::endl;
	std::cout << x<<std::endl;
}

Chcę aby po wpisaniu błędnej wartości x funkcja się uruchomiła ponownie, a gdy błędna jest wartość y program wyświetlił podaną wartość x ("Podaj x: x") a potem znów poprosił o podanie wartości y. Wszystko dobrze działa dopóki nie poda się złej wartości (np. "abcd" zamiast liczby itd.). Po wpisaniu błędnej wartości program jakby wraca do wyjątku tyle razy ile wystąpił błąd w w trakcie wykonywania funkcji i w efekcie albo 2 ostatnie linijki działają kilka razy albo kod "Podaj wartość y: " wykonuje się kilka razy. Nie wiem dlaczego tak jest i jak to naprawić. Z góry dzięki za pomoc.

Answer 1

Nie wiem dlaczego tak jest  (...)

Jest tak dlatego, że wykonujesz funkcję rekurencyjnie.

(...) i jak to naprawić.

Napisać po ludzku funkcję, bez wyjątków i rekurencji. Zwykła pętla wystarczy.

Comments

Skoro pętla wystarczy to w jaki sposób zwalidować dane np. w funkcji stoi?

---

int readValue(const char* text)
{
    int v;

    while (1) {   
        std::cout << text; 
        std::cin >> v;
        
        if(std::cin.fail()){
            std::cout << "Nieprawidlowy format liczby\n";
            std::cin.clear();
            std::cin.ignore(666, '\n');
            continue;
        }
        
        if(v <= 0) {
            std::cout << "Wartosc musi byc >0\n";
            continue;
        }
        
        break;
    }
    
    return v;
}

int main()
{
    int x = readValue("Podaj x: ");
    int y = readValue("Podaj y: ");
    
    std::cout << x << ", " << y << '\n';
}

 

---

Ok to rozumiem, faktycznie można w ten sposób to zrobić, ale chciałbym zrozumieć i dowiedzieć się dlaczego napisany przeze mnie kod nie działa. Jakiś pomysł?

---

No to pisałem, że chodzi o rekurencję. Jeśli zrobisz błąd w x, to w obsłudze błędu wywołujesz tę samą funkcję. I jeśli w niej podasz poprawnie x i y, to po wyskoczeniu z funkcji zostaniesz znowu poproszony o podanie wartości y.

void mojaFunckja(std::string alert)
{
    /* ...  */
    
        catch (std::invalid_argument) {
            mojaFunckja("Zla wartosc"); // po wyskoczeniu stąd ...
        }
 
 
    std::cout << "Podaj y: "; //... funkcja jest dalej kontynuowana
 
    /* itd */
}

Wystarczy dać return w catch i problem powinien zniknąć.

---

Czyli dobrze rozumiem, że try..catch po wykonaniu funkcji catch nie "stopuje" funkcji, nie robi break czy coś w tym stylu i po prostu idzie dalej z kodem?

---

jeśli nie obsługujesz błędu, nie zwracasz i nie robisz innej akcji to po prostu łapie Ci wyjątek i idzie dalej
 

catch (std::exception e) {
            mojaFunckja("Blad: " + static_cast<std::string>(e.what()));
        }

catch wyłapie execption, ale ty wywołujesz funkcje 
mojaFunckja("Blad: " + static_cast<std::string>(e.what()));
Wiec ona znowu odpala się od początku i leci dalej, stąd duplikacje tak jak tkz napisal rekurencja. 

---

Ok dzięki za odp.