9.x — Podsumowanie i quiz rozdziału 9

Przegląd rozdziału

Zakres pełzanie ma miejsce, gdy możliwości projektu przekraczają pierwotne zamierzenia na początku projektu lub fazy projektu.

Weryfikacja oprogramowania to proces sprawdzania, czy oprogramowanie działa zgodnie z oczekiwaniami we wszystkich przypadkach. Test jednostkowy to test zaprojektowany w celu przetestowania małej części kodu (zwykle funkcji lub wywołania) w izolacji, aby upewnić się, że określone zachowanie zachodzi zgodnie z oczekiwaniami. Struktury testów jednostkowych mogą pomóc w zorganizowaniu testów jednostkowych. Testy integracyjne testują integrację kilku jednostek razem w celu zapewnienia ich działają poprawnie.

Pokrycie kodu odnosi się do tego, jaka część kodu źródłowego jest wykonywana podczas testowania. Pokrycie instrukcji odnosi się do procentu instrukcji w programie, które zostały sprawdzone przez procedury testowe. Pokrycie gałęzi odnosi się do procentu gałęzi, które zostały wykonane przez testowanie procedury. Pokrycie pętli (zwane także testem 0, 1, 2) oznacza, że jeśli masz pętlę, powinieneś upewnić się, że działa ona poprawnie, wykonując iteracje 0, 1 raz i 2 razy.

Klasa szczęśliwą ścieżkę to ścieżka wykonania, która ma miejsce, gdy nie napotkano żadnych błędów. Smutna ścieżka to taka, w której występuje błąd lub stan awarii. A nieodwracalny błąd (zwana także błędem krytycznym błąd) to błąd na tyle poważny, że program nie może kontynuować działania. Program, który dobrze radzi sobie z błędami, to solidny.

A bufor to fragment pamięci przeznaczony do tymczasowego przechowywania danych podczas ich przenoszenia z jednego miejsca do drugiego.

Proces sprawdzania, czy dane wejściowe użytkownika są zgodne z oczekiwaniami programu, nazywa się weryfikacja danych wejściowych.

std::cerr jest strumieniem wyjściowym (jak std::cout) przeznaczony do stosowania w komunikatach o błędach.

A warunek wstępny to dowolny warunek, który musi zawsze być spełniony przed wykonaniem jakiegoś segmentu kodu. An Niezmiennik to warunek, który musi być spełniony podczas wykonywania jakiegoś komponentu. A warunek końcowy to dowolny warunek, który zawsze musi być spełniony po wykonaniu jakiegoś kodu.

An Asercja jest wyrażeniem, które będzie prawdziwe, chyba że w programie wystąpi błąd. W języku C++ asercje środowiska wykonawczego są zwykle implementowane przy użyciu makra makro preprocesoraassert preprocesora. Asercje są zwykle wyłączone w kodzie innym niż debugowanie. A static_assert jest asercją ocenianą w czasie kompilacji.

Asercji należy używać do dokumentowania przypadków, które powinny być logicznie niemożliwe. Do obsługi możliwych przypadków należy używać obsługi błędów.

Czas quizu

Pytanie nr 1

W quizie dotyczącym lekcji 8.x — podsumowanie rozdziału 8 i quiz zaimplementowaliśmy grę Hi-Lo.

Zaktualizuj swoje poprzednie rozwiązanie, aby obsługiwać nieprawidłowe domysły (np. „x”), domysły wykraczające poza zakres (np. 0 lub 101) lub prawidłowe domysły które zawierają obce znaki (np. 43x). Obsługuj także użytkownika wprowadzającego dodatkowe znaki, gdy gra zapyta go, czy chce zagrać ponownie.

Wskazówka: Napisz osobną funkcję do obsługi użytkownika wprowadzającego swoje przypuszczenie (wraz z powiązaną obsługą błędów).

Pokaż rozwiązanie

#include <iostream>
#include <limits>   // for std::numeric_limits
#include "Random.h" // /www.learncpp.com/cpp-tutorial/global-random-numbers-random-h/

int getGuess(int count, int min, int max)
{
	while (true) // loop until user enters valid input
	{
		std::cout << "Guess #" << count << ": ";

		int guess {};
		std::cin >> guess;

		bool success { std::cin };
		std::cin.clear(); // put us back in 'normal' operation mode (if needed)
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // remove any extra input

		// If we didn't extract anything or the extracted guess is out of bounds, try again
		if (!success || guess < min || guess > max)
			continue;

		return guess;
	}
}

// returns true if the user won, false if they lost
bool playHiLo(int guesses, int min, int max)
{
	std::cout << "Let's play a game. I'm thinking of a number between " << min << " and " << max << ". You have " << guesses << " tries to guess what it is.\n";
	int number{ Random::get(min, max) }; // this is the number the user needs to guess

	// Loop through all of the guesses
	for (int count{ 1 }; count <= guesses; ++count)
	{
		int guess{ getGuess(count, min, max) };

		if (guess > number)
			std::cout << "Your guess is too high.\n";
		else if (guess < number)
			std::cout << "Your guess is too low.\n";
		else // guess == number, so the user won
		{
			std::cout << "Correct! You win!\n";
			return true;
		}
	}

	// The user lost
	std::cout << "Sorry, you lose. The correct number was " << number << '\n';
	return false; // if the user lost
}

bool playAgain()
{
	// Keep asking the user if they want to play again until they pick y or n.
	while (true)
	{
		char ch{};
		std::cout << "Would you like to play again (y/n)? ";
		std::cin >> ch;

		// clear out any extraneous input
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        
		switch (ch)
		{
		case 'y': return true;
		case 'n': return false;
		}
	}
}

int main()
{
	constexpr int guesses { 7 }; // the user has this many guesses
	constexpr int min     { 1 };
	constexpr int max     { 100 };

	do
	{
		playHiLo(guesses, min, max);
	} while (playAgain());

	std::cout << "Thank you for playing.\n";

	return 0;
}