循环、函数和组织的问题
trouble with loops, functions, and organization´
首先我想说这不是当前的家庭作业；但这是 3 年前我辍学前的作业。我正在自学，正在重温一项旧作业。我并不是要整个程序，我只是在寻求帮助构建游戏初始阶段的骨架。
更多信息：
玩家 1 将输入单词（任意长度/我一直在使用“测试”）供玩家 2 猜测。玩家 2 将有 5 个字母猜测和 5 个单词猜测。如果玩家 2 进入“测试”，它应该能够忽略 upper/lower 之间的大小写（不使用 toupper / tolower）
如果：玩家 2 输入超过 1 个字母进行猜测：“aa”让他们再次猜测，直到他们只猜到 1 个字母“a”。
我面临的问题是：我不知道把所有东西放在哪里，我觉得我在混淆或搞乱功能，每次我试图组织它时，情况只会变得更糟。我已经重新启动它好几次了，我只是很难把它全部布置好。
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
int main()
{
string word, wordguess, lower, dashes;
string letterguess;
int i = 0;
bool GameOver = false, Validletterguess = true, Validwordguess = true;
cout << "Player 1, enter a word for Player 2 to guess: " << endl;
getline(cin, word);
cout << endl;
cout << "Player 2, you have 5 letter guesses, and 5 word guesses." << endl;
cout << "Guess your first letter: " << endl;
while (GameOver == false) // Start of Game. Setup for Round 1 letter guess and word guess.
{
while (letterguess.length() != 1) // 1 letter only. loop until they enter 1 letter
{
cout << endl << "Type a single letter and press <enter>: ";
cin >> letterguess; // enter letter guess
for (int i = 0; i < letterguess.length(); i++) //ignore case of letter guess
{
if (letterguess.at(i) >= 'A' && letterguess.at(i) <= 'Z')
{
lower += letterguess.at(i) + 32;
}
else
{
lower += letterguess.at(i);
}
}
if (letterguess.at(i) == word.at(i) && Validletterguess == true) //if Player2 guesses a correct letter, replace the dash with letter and display location: ex. If "T" then "You guessed the 1st and 4th letter"
{
cout << "You guessed the first letter right!" << endl; // figure out how to display dashes?
dashes.at(i) = letterguess.at(i);
cout << "Enter your first word guess: " << endl;
cin >> wordguess;
}
else
cout << "Wrong letter! Enter your first word guess: " << endl;
cin >> wordguess;
if (wordguess == word & Validwordguess = true)
{
cout << "You guessed the word correctly in 1 try! " << endl;
Gameover = true;
}
}
}
}
C++ 中有几项可以帮助您。很高兴看到您已经在使用 std::string 和 std::getline 来处理用户输入。问题似乎是您在组织游戏逻辑以使其流动以及设置可以帮助您的结构方面遇到了麻烦。
我确实继续写了一个游戏只是为了好玩。希望我能提供其中的一些内容并对其进行描述，以便您可以分块消化，并且您可以了解如何一次构建一个程序。
所以让我们开始为实际 运行 游戏的函数创建一个存根。您可以从 main 调用它。它通过将游戏与其他设置和关闭内容分开，简化了游戏的实际 运行ning。这也意味着您可以在以后连续 运行 几个游戏，而无需修改游戏循环。
enum GameResult {
None,
Win,
Loss,
};
GameResult PlayHangman(const std::string& target, int wrongLetterLimit, int wrongWordLimit)
{
return None;
}
为了说明这一点，这里是我最终为调用该游戏而编写的完整 main。尽管它是 one-off，但您可以看到它很有用。在这种情况下，我选择从命令行读取游戏设置：
void ExitSyntaxMessage(int code = -1)
{
std::cerr << "Syntax: hangman <word> [guesses [wordGuesses]]\n";
exit(code);
}
int main(int argc, char** argv)
{
// Get game settings
std::string target;
int letterGuesses = 5;
int wordGuesses = 5;
try {
if (argc < 2) throw std::runtime_error("Not enough arguments");
target = argv[1];
if (argc > 2) letterGuesses = std::stoi(argv[2]);
if (argc > 3) wordGuesses = std::stoi(argv[3]);
}
catch(...)
{
ExitSyntaxMessage();
}
// Play game
GameResult result = PlayHangman(target, letterGuesses, wordGuesses);
// Deliver result and exit
switch(result)
{
case Win:
std::cout << "Congratulations!\n";
return 0;
case Loss:
std::cout << "Better luck next time!\n";
return 1;
default:
std::cout << "Game stopped.\n";
return -2;
}
}
那么，现在您的游戏有了一个简单的框架 运行。代码不多，但您可以立即开始测试，然后再充实游戏本身。
在这一点上，我应该提一下这个程序需要的一些 headers。有些已经被要求了。我们将要做的事情还需要其他人。
#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <set>
进入游戏...将字符串转换为小写的辅助函数总是很方便。我们一定会利用它。请注意，这使用了 lambda 函数。如果您没有现代 C++ 编译器（支持 C++11），您可以使用普通函数指针代替。
std::string Lowercase(const std::string& s)
{
std::string lc(s);
std::transform(lc.begin(), lc.end(), lc.begin(),
[](char c)->char{ return std::tolower(c); });
return lc;
}
现在是扩展 PlayHangman 存根的时候了。它仍然是一个存根，但我们可以设置一些我们需要的东西，并在继续之前进行测试。
GameResult PlayHangman(const std::string& target, int wrongLetterLimit, int wrongWordLimit)
{
GameResult result = None;
// Create lowercase target and add its characters to set of remaining letters
std::string lcTarget = Lowercase(target);
std::set<char> lettersRemaining(lcTarget.begin(), lcTarget.end());
std::set<std::string> guesses;
// Set up game parameters
int letterGuessesRemaining = wrongLetterLimit;
int wordGuessesRemaining = wrongWordLimit;
// Sanity-test to ensure game is winnable
if (wordGuessesRemaining == 0 && letterGuessesRemaining < lettersRemaining.size())
{
std::cout << "Game is not winnable...\n";
return None;
}
// Game loop until stream error or game finishes
bool done = false;
while (!done)
{
done = true; // The loop is a stub for now
}
//// ^^^ for now, just use this bit to test the game setup stuff.
//// Make sure that your lowercase bits are working and the set of
//// remaining letters works. You can add some output code to debug
//// their values and run tests from the command line to verify.
return result;
}
这将是单个游戏的主要结构。那么让我们来谈谈吧。再次注意我仍然没有详细说明。在这一点上，我已经考虑过在逻辑上我应该如何运行玩游戏。
现在，我应该说，在现实中，大多数人不会像这样从外到内以线性方式编写代码。这更像是一个有机过程，但我 注意将内容分成逻辑位，然后 reshuffle/organize 内容。我也尽量不要一次做太多。
您会通过我介绍的方式看到，我鼓励您开发一个可靠的平台来编写您的游戏逻辑。当您编写该逻辑时，您应该能够相信其他一切都已经正常工作，因为您已经对其进行了测试。
上面发生的事情有：
- 目标字符串被复制到其自身的小写版本中。这将用于测试 word-guesses。还有其他方法可以忽略大小写来测试字符串，但这只是一种简单的方法。
- 因为我们已经构建了该字符串，所以我们还可以使用它来构建一个
std::set，其中恰好包含该字符串中每个唯一字符的一个。这是一个 one-liner，从字符串的迭代器构造集合。非常整洁！
- 我们还有一组名为
guesses 的字符串——这将跟踪所有的猜测（包括 correct/incorrect），这样您就不会因为不小心重复已经猜到的内容而受到惩罚。
- 有一个健全性检查，它与最终将成为循环内的 end-game 测试的副本相同。老实说，这是我最后添加的东西之一，但我把它放在这里是因为它是 pre-game 设置的一部分，除了存根循环之外，这是整个“游戏”序列。
检查点：游戏骨架完成
至此，您可能已经看得够多了，可以开始并完成游戏了。上面介绍了一些重要的概念。特别是，将剩余的字母存储为 std::set 的想法可能正是让一切都井井有条的技巧。
从这里开始阅读将完成该程序。是否要这样做取决于您，还是停止阅读并先自己尝试一下。
让我们开始充实一些游戏循环。首先，您可能想要处理显示当前游戏状态和请求输入的问题。这分两步发生。第一部分通过隐藏尚未猜到的字符构建一个字符串，然后将其输出。第二部分是一个 input-validating 循环，它丢弃空行，忽略重复的猜测并处理 end-of-stream.
请注意，输入已转换为小写。这只是简化了事情。特别是在检查重复猜测时。
while (!done)
{
// Create prompt from original string with a dash for each hidden character
std::string prompt(target);
for(char& c : prompt)
{
if (lettersRemaining.count(std::tolower(c)) != 0) c = '-';
}
std::cout << prompt << "\n";
// Get input
std::string input;
for (bool validInput = false; !validInput && !done; )
{
std::cout << "> " << std::flush;
if (!std::getline(std::cin, input))
{
done = true;
}
else if (!input.empty())
{
input = Lowercase(input);
validInput = guesses.insert(input).second;
if (!validInput)
{
std::cout << "You already guessed that!\n";
}
}
}
if (done)
continue;
// TODO: Process guess, update game state, and check end-game conditions
}
我们再次扩展了实现，现在有一些东西可以测试。所以确保它全部编译并按照你的方式工作你想要它。显然游戏现在将 运行 永远，但没关系——您可以终止该过程。
当你开心的时候，继续真正的逻辑。这是我们开始将所有已经设置好的东西放在一起的地方。
感谢我们的输入循环，我们现在知道输入现在是一个包含 1 个字母或一个单词的新猜测。因此，我首先对字母 guess 或单词 guess 进行分支。你应该开始在这里看到一个模式，对吧？再一次，我写了一段空代码来做某事，然后 然后 开始实际填充它...
// Check the guessed letter or word
bool correctGuess = false;
if (input.size() == 1)
{
if (letterGuessesRemaining == 0)
{
std::cout << "No more letter guesses remain.\n";
}
else
{
// Test the guessed letter
}
}
else
{
if (wordGuessesRemaining == 0)
{
std::cout << "No more word guesses remain.\n";
}
else
{
// Test the guessed word
}
}
所以，字母测试...回想一下，我们已经构建了 lettersRemaining 集并对其进行了测试。这些是提示中唯一被破折号遮盖的部分。因此，确定他们是否猜到了一个就变得微不足道了。如果它在集合中，他们猜对了，你就将它从集合中移除。否则，他们会烧毁他们的猜测之一。
因为输入已经是小写的，所以我们可以使用字母逐字搜索存储在集合中的值（也是小写）。
// Test the guessed letter
char letter = input[0];
if (lettersRemaining.count(letter) != 0)
{
correctGuess = true;
lettersRemaining.erase(letter);
}
else
{
std::cout << "Nope!\n";
--letterGuessesRemaining;
}
单词测试就更简单了。回想一下，我们已经存储了目标词的小写版本，并且输入也被转换为小写。所以我们只是比较。您看到所有这些小写业务实际上如何让生活变得不那么复杂了吗？
// Test the guessed word
if (input == lcTarget)
{
correctGuess = true;
lettersRemaining.clear(); //<-- we can use this to test for a win
}
else
{
std::cout << "Nope!\n";
--wordGuessesRemaining;
}
我们真的快完成了！唯一剩下要做的就是检查游戏是否应该因输赢而停止。这是游戏循环的最后一部分。
因为处理正确单词猜测的代码也很礼貌并清除 lettersRemaining 集，我们可以将其用作获胜条件的测试，而不管是否猜到了字母或单词。
您还会再次看到游戏失败条件的逻辑。回想一下在主循环之前我们检查是否有可能获胜。
// If guessed incorrectly, show remaining attempts
if (!correctGuess)
{
std::cout << "\nAttempts remaining: "
<< letterGuessesRemaining << " letters, "
<< wordGuessesRemaining << " words.\n";
}
// Check if game is complete
if (lettersRemaining.empty())
{
std::cout << target << "\n";
result = Win;
done = true;
}
else if (wordGuessesRemaining == 0 && letterGuessesRemaining < lettersRemaining.size())
{
std::cout << target << "\n";
result = Loss;
done = true;
}
我希望这对您有所帮助，希望您能够跟进并理解分解和解释。这通常是我处理编程的方式。我喜欢构建我可以依赖的代码片段，而不是迷失在一些细节中而忽视更基本的东西。
这里可能使用了一些您以前没有遇到过的技术、语言特性或部分标准库。这很好——您可以使用它来在线学习、实验和研究。在您的浏览器中保存 https://cppreference.com 书签。
如果没有别的，我希望这能给您一些洞察力，将任务分解成您现在关心的小部分，以及您以后可以担心的其他事情。以这种方式迭代地构建程序使您能够定期测试代码并增加发现愚蠢错误的机会，这些错误可能会在以后妨碍您。经常看到初学者一下子写完整个程序，运行，然后因为它不“工作”而吓坏了。
首先我想说这不是当前的家庭作业；但这是 3 年前我辍学前的作业。我正在自学，正在重温一项旧作业。我并不是要整个程序，我只是在寻求帮助构建游戏初始阶段的骨架。
更多信息： 玩家 1 将输入单词（任意长度/我一直在使用“测试”）供玩家 2 猜测。玩家 2 将有 5 个字母猜测和 5 个单词猜测。如果玩家 2 进入“测试”，它应该能够忽略 upper/lower 之间的大小写（不使用 toupper / tolower） 如果：玩家 2 输入超过 1 个字母进行猜测：“aa”让他们再次猜测，直到他们只猜到 1 个字母“a”。
我面临的问题是：我不知道把所有东西放在哪里，我觉得我在混淆或搞乱功能，每次我试图组织它时，情况只会变得更糟。我已经重新启动它好几次了，我只是很难把它全部布置好。
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
int main()
{
string word, wordguess, lower, dashes;
string letterguess;
int i = 0;
bool GameOver = false, Validletterguess = true, Validwordguess = true;
cout << "Player 1, enter a word for Player 2 to guess: " << endl;
getline(cin, word);
cout << endl;
cout << "Player 2, you have 5 letter guesses, and 5 word guesses." << endl;
cout << "Guess your first letter: " << endl;
while (GameOver == false) // Start of Game. Setup for Round 1 letter guess and word guess.
{
while (letterguess.length() != 1) // 1 letter only. loop until they enter 1 letter
{
cout << endl << "Type a single letter and press <enter>: ";
cin >> letterguess; // enter letter guess
for (int i = 0; i < letterguess.length(); i++) //ignore case of letter guess
{
if (letterguess.at(i) >= 'A' && letterguess.at(i) <= 'Z')
{
lower += letterguess.at(i) + 32;
}
else
{
lower += letterguess.at(i);
}
}
if (letterguess.at(i) == word.at(i) && Validletterguess == true) //if Player2 guesses a correct letter, replace the dash with letter and display location: ex. If "T" then "You guessed the 1st and 4th letter"
{
cout << "You guessed the first letter right!" << endl; // figure out how to display dashes?
dashes.at(i) = letterguess.at(i);
cout << "Enter your first word guess: " << endl;
cin >> wordguess;
}
else
cout << "Wrong letter! Enter your first word guess: " << endl;
cin >> wordguess;
if (wordguess == word & Validwordguess = true)
{
cout << "You guessed the word correctly in 1 try! " << endl;
Gameover = true;
}
}
}
}
C++ 中有几项可以帮助您。很高兴看到您已经在使用 std::string 和 std::getline 来处理用户输入。问题似乎是您在组织游戏逻辑以使其流动以及设置可以帮助您的结构方面遇到了麻烦。
我确实继续写了一个游戏只是为了好玩。希望我能提供其中的一些内容并对其进行描述，以便您可以分块消化，并且您可以了解如何一次构建一个程序。
所以让我们开始为实际 运行 游戏的函数创建一个存根。您可以从 main 调用它。它通过将游戏与其他设置和关闭内容分开，简化了游戏的实际 运行ning。这也意味着您可以在以后连续 运行 几个游戏，而无需修改游戏循环。
enum GameResult {
None,
Win,
Loss,
};
GameResult PlayHangman(const std::string& target, int wrongLetterLimit, int wrongWordLimit)
{
return None;
}
为了说明这一点，这里是我最终为调用该游戏而编写的完整 main。尽管它是 one-off，但您可以看到它很有用。在这种情况下，我选择从命令行读取游戏设置：
void ExitSyntaxMessage(int code = -1)
{
std::cerr << "Syntax: hangman <word> [guesses [wordGuesses]]\n";
exit(code);
}
int main(int argc, char** argv)
{
// Get game settings
std::string target;
int letterGuesses = 5;
int wordGuesses = 5;
try {
if (argc < 2) throw std::runtime_error("Not enough arguments");
target = argv[1];
if (argc > 2) letterGuesses = std::stoi(argv[2]);
if (argc > 3) wordGuesses = std::stoi(argv[3]);
}
catch(...)
{
ExitSyntaxMessage();
}
// Play game
GameResult result = PlayHangman(target, letterGuesses, wordGuesses);
// Deliver result and exit
switch(result)
{
case Win:
std::cout << "Congratulations!\n";
return 0;
case Loss:
std::cout << "Better luck next time!\n";
return 1;
default:
std::cout << "Game stopped.\n";
return -2;
}
}
那么，现在您的游戏有了一个简单的框架 运行。代码不多，但您可以立即开始测试，然后再充实游戏本身。
在这一点上，我应该提一下这个程序需要的一些 headers。有些已经被要求了。我们将要做的事情还需要其他人。
#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <set>
进入游戏...将字符串转换为小写的辅助函数总是很方便。我们一定会利用它。请注意，这使用了 lambda 函数。如果您没有现代 C++ 编译器（支持 C++11），您可以使用普通函数指针代替。
std::string Lowercase(const std::string& s)
{
std::string lc(s);
std::transform(lc.begin(), lc.end(), lc.begin(),
[](char c)->char{ return std::tolower(c); });
return lc;
}
现在是扩展 PlayHangman 存根的时候了。它仍然是一个存根，但我们可以设置一些我们需要的东西，并在继续之前进行测试。
GameResult PlayHangman(const std::string& target, int wrongLetterLimit, int wrongWordLimit)
{
GameResult result = None;
// Create lowercase target and add its characters to set of remaining letters
std::string lcTarget = Lowercase(target);
std::set<char> lettersRemaining(lcTarget.begin(), lcTarget.end());
std::set<std::string> guesses;
// Set up game parameters
int letterGuessesRemaining = wrongLetterLimit;
int wordGuessesRemaining = wrongWordLimit;
// Sanity-test to ensure game is winnable
if (wordGuessesRemaining == 0 && letterGuessesRemaining < lettersRemaining.size())
{
std::cout << "Game is not winnable...\n";
return None;
}
// Game loop until stream error or game finishes
bool done = false;
while (!done)
{
done = true; // The loop is a stub for now
}
//// ^^^ for now, just use this bit to test the game setup stuff.
//// Make sure that your lowercase bits are working and the set of
//// remaining letters works. You can add some output code to debug
//// their values and run tests from the command line to verify.
return result;
}
这将是单个游戏的主要结构。那么让我们来谈谈吧。再次注意我仍然没有详细说明。在这一点上，我已经考虑过在逻辑上我应该如何运行玩游戏。
现在，我应该说，在现实中，大多数人不会像这样从外到内以线性方式编写代码。这更像是一个有机过程，但我 注意将内容分成逻辑位，然后 reshuffle/organize 内容。我也尽量不要一次做太多。
您会通过我介绍的方式看到，我鼓励您开发一个可靠的平台来编写您的游戏逻辑。当您编写该逻辑时，您应该能够相信其他一切都已经正常工作，因为您已经对其进行了测试。
上面发生的事情有：
- 目标字符串被复制到其自身的小写版本中。这将用于测试 word-guesses。还有其他方法可以忽略大小写来测试字符串，但这只是一种简单的方法。
- 因为我们已经构建了该字符串，所以我们还可以使用它来构建一个
std::set，其中恰好包含该字符串中每个唯一字符的一个。这是一个 one-liner，从字符串的迭代器构造集合。非常整洁！ - 我们还有一组名为
guesses的字符串——这将跟踪所有的猜测（包括 correct/incorrect），这样您就不会因为不小心重复已经猜到的内容而受到惩罚。 - 有一个健全性检查，它与最终将成为循环内的 end-game 测试的副本相同。老实说，这是我最后添加的东西之一，但我把它放在这里是因为它是 pre-game 设置的一部分，除了存根循环之外，这是整个“游戏”序列。
检查点：游戏骨架完成
至此，您可能已经看得够多了，可以开始并完成游戏了。上面介绍了一些重要的概念。特别是，将剩余的字母存储为 std::set 的想法可能正是让一切都井井有条的技巧。
从这里开始阅读将完成该程序。是否要这样做取决于您，还是停止阅读并先自己尝试一下。
让我们开始充实一些游戏循环。首先，您可能想要处理显示当前游戏状态和请求输入的问题。这分两步发生。第一部分通过隐藏尚未猜到的字符构建一个字符串，然后将其输出。第二部分是一个 input-validating 循环，它丢弃空行，忽略重复的猜测并处理 end-of-stream.
请注意，输入已转换为小写。这只是简化了事情。特别是在检查重复猜测时。
while (!done)
{
// Create prompt from original string with a dash for each hidden character
std::string prompt(target);
for(char& c : prompt)
{
if (lettersRemaining.count(std::tolower(c)) != 0) c = '-';
}
std::cout << prompt << "\n";
// Get input
std::string input;
for (bool validInput = false; !validInput && !done; )
{
std::cout << "> " << std::flush;
if (!std::getline(std::cin, input))
{
done = true;
}
else if (!input.empty())
{
input = Lowercase(input);
validInput = guesses.insert(input).second;
if (!validInput)
{
std::cout << "You already guessed that!\n";
}
}
}
if (done)
continue;
// TODO: Process guess, update game state, and check end-game conditions
}
我们再次扩展了实现，现在有一些东西可以测试。所以确保它全部编译并按照你的方式工作你想要它。显然游戏现在将 运行 永远，但没关系——您可以终止该过程。
当你开心的时候，继续真正的逻辑。这是我们开始将所有已经设置好的东西放在一起的地方。
感谢我们的输入循环，我们现在知道输入现在是一个包含 1 个字母或一个单词的新猜测。因此，我首先对字母 guess 或单词 guess 进行分支。你应该开始在这里看到一个模式，对吧？再一次，我写了一段空代码来做某事，然后 然后 开始实际填充它...
// Check the guessed letter or word
bool correctGuess = false;
if (input.size() == 1)
{
if (letterGuessesRemaining == 0)
{
std::cout << "No more letter guesses remain.\n";
}
else
{
// Test the guessed letter
}
}
else
{
if (wordGuessesRemaining == 0)
{
std::cout << "No more word guesses remain.\n";
}
else
{
// Test the guessed word
}
}
所以，字母测试...回想一下，我们已经构建了 lettersRemaining 集并对其进行了测试。这些是提示中唯一被破折号遮盖的部分。因此，确定他们是否猜到了一个就变得微不足道了。如果它在集合中，他们猜对了，你就将它从集合中移除。否则，他们会烧毁他们的猜测之一。
因为输入已经是小写的，所以我们可以使用字母逐字搜索存储在集合中的值（也是小写）。
// Test the guessed letter
char letter = input[0];
if (lettersRemaining.count(letter) != 0)
{
correctGuess = true;
lettersRemaining.erase(letter);
}
else
{
std::cout << "Nope!\n";
--letterGuessesRemaining;
}
单词测试就更简单了。回想一下，我们已经存储了目标词的小写版本，并且输入也被转换为小写。所以我们只是比较。您看到所有这些小写业务实际上如何让生活变得不那么复杂了吗？
// Test the guessed word
if (input == lcTarget)
{
correctGuess = true;
lettersRemaining.clear(); //<-- we can use this to test for a win
}
else
{
std::cout << "Nope!\n";
--wordGuessesRemaining;
}
我们真的快完成了！唯一剩下要做的就是检查游戏是否应该因输赢而停止。这是游戏循环的最后一部分。
因为处理正确单词猜测的代码也很礼貌并清除 lettersRemaining 集，我们可以将其用作获胜条件的测试，而不管是否猜到了字母或单词。
您还会再次看到游戏失败条件的逻辑。回想一下在主循环之前我们检查是否有可能获胜。
// If guessed incorrectly, show remaining attempts
if (!correctGuess)
{
std::cout << "\nAttempts remaining: "
<< letterGuessesRemaining << " letters, "
<< wordGuessesRemaining << " words.\n";
}
// Check if game is complete
if (lettersRemaining.empty())
{
std::cout << target << "\n";
result = Win;
done = true;
}
else if (wordGuessesRemaining == 0 && letterGuessesRemaining < lettersRemaining.size())
{
std::cout << target << "\n";
result = Loss;
done = true;
}
我希望这对您有所帮助，希望您能够跟进并理解分解和解释。这通常是我处理编程的方式。我喜欢构建我可以依赖的代码片段，而不是迷失在一些细节中而忽视更基本的东西。
这里可能使用了一些您以前没有遇到过的技术、语言特性或部分标准库。这很好——您可以使用它来在线学习、实验和研究。在您的浏览器中保存 https://cppreference.com 书签。
如果没有别的，我希望这能给您一些洞察力，将任务分解成您现在关心的小部分，以及您以后可以担心的其他事情。以这种方式迭代地构建程序使您能够定期测试代码并增加发现愚蠢错误的机会，这些错误可能会在以后妨碍您。经常看到初学者一下子写完整个程序，运行，然后因为它不“工作”而吓坏了。