Question

我一般都不熟悉C＃和编码。基本上，当我问用户是否想要额外的浇头时，我将答案设置为布尔值。问题在于，当它们选择true时，数组将遍历每个索引。我的for循环有问题吗？

我尝试在for循环中使用其他参数。

string[] size = { "small", "medium", "large", "x-large" };
double[] price = {6.99, 8.99, 12.50, 15.00};
double[] extra = { 1.00, 2.00, 3.25, 4.50 }; //extra toppings

            Console.Write("Pizza Sizes: Small, Medium, Large, X-Large ");
            Console.WriteLine();
            Console.Write("Enter a the pizza size you would like to order:");

            string pizzaSize = Console.ReadLine();
            Console.WriteLine("You selected size  {0}:", pizzaSize);

            Console.WriteLine("Would you like extra toppings? true or false?");
            bool addons = Convert.ToBoolean(Console.ReadLine());
            Console.WriteLine("You selected {0}", addons);

            for (int i = 0; i < size.Length; i++)

            {
                if (size[i] == pizzaSize)
                {
                    Console.WriteLine("You ordered a {0} pizza for ${1}", pizzaSize, price[i]);
                }

                if (addons == true)

                {
                    Console.WriteLine("You ordered a {0} pizza with extra toppings. The total price is {1}", pizzaSize, price[i] + extra[i]);
                }
                Console.ReadLine();

如果客户只想要某个尺寸的比萨，则阵列应返回比萨的价格，但是，如果客户希望添加浇头，则平行阵列应返回比萨的总价加上额外的浇头。

Answer 1

您在代码中实现了错误的逻辑。

您的for循环将像往常一样循环通过，如果用户想要填充（如addons == true），它将运行以下代码：

Console.WriteLine（“您订购了带有额外浇头的{0}披萨。总价格为{1}”，pizzaSize，价格[i] +额外[i]）；

由于这是一个循环，因此每次在addons == true时都会运行。首先是i = 0，然后是i = 1，等等。

如果您发现这有帮助，请标记为已解决。祝好运。：）

编辑：

考虑将if放入if中。

Answer 2

您正在循环中打印信息。您真正想要循环做的就是识别正确的大小索引，以便您可以使用它来引用其他数组，对吧？

int selSize = -1;
for (int i = 0; i < size.Length; i++)
{
    if (size[i] == pizzaSize)
    {
        selSize = i;
        break;
    }
}

if (addons == true)
{
    Console.WriteLine("You ordered a {0} pizza with extra toppings. The total price is {1}", pizzaSize, price[selSize] + extra[selSize]);
}
else
{
    Console.WriteLine("You ordered a {0} pizza for ${1}", pizzaSize, price[selSize]);
}
Console.ReadLine();

这样，循环只执行它需要做的事情，并且将不需要循环的逻辑带到它的块之外。

Answer 3

在此示例中，您只需要循环一次，并且仅循环通过size数组才能找到与输入的披萨大小相对应的索引。

顺便说一句，在现实生活中，您还应该期望输入无效并处理这种情况。另外，decimal应该更适合处理价格，避免在数学运算后使用0.999999999而不是1。

请参见以下示例。如果找到匹配项，您可以使用while和for来代替break，这是个人喜好问题...

const int arraySize = 4;
string[] pizzaSizes = { "Small", "Medium", "Large", "X-Large" };
decimal[] prices = { 6.99M, 8.99M, 12.50M, 15.00M };
decimal[] extras = { 1.00M, 2.00M, 3.25M, 4.50M }; //extra toppings

Console.WriteLine("Pizza Sizes: Small, Medium, Large, X-Large ");
Console.Write("Enter a the pizza size you would like to order:");

string pizzaSize = Console.ReadLine();
int i = 0;
// Important to have condition (i < arraySize) the first in evalution 
while ((i < arraySize) && (pizzaSizes[i] != pizzaSize))
{
    ++i;
}

if (i >= arraySize)
{
    // Invalid input
    Console.WriteLine($"Invalid pizza size input: {pizzaSize}. Exiting");
    return;
}

Console.WriteLine("You selected a {0} pizza for ${1}", pizzaSizes[i], prices[i]);

Console.WriteLine("Would you like extra toppings? true or false?");
bool addons = Convert.ToBoolean(Console.ReadLine());
Console.WriteLine("You selected {0}", addons);

if (addons)
{
    Console.WriteLine($"You ordered a {pizzaSizes[i]} pizza with extra toppings. The total price is {prices[i] + extras[i]}");
}
else
{
    Console.WriteLine($"You ordered a {pizzaSizes[i]} pizza without extra toppings. The total price is {prices[i]}");
}
Console.ReadLine();

Answer 4

这就是我要做的。首先是大小的枚举：

public enum PizzaSize
{
    Small,
    Medium,
    Large,
    XLarge,
}

然后，价格信息：

    private static readonly Dictionary<PizzaSize, decimal> PizzaPrices = new Dictionary<PizzaSize, decimal>
    {
        {PizzaSize.Small, 6.99m},
        {PizzaSize.Medium, 8.99m },
        {PizzaSize.Large, 12.50m },
        {PizzaSize.XLarge, 15.00m }
    };
    private static readonly Dictionary<PizzaSize, decimal> ToppingsPrices = new Dictionary<PizzaSize, decimal>
    {
        {PizzaSize.Small, 1.00m},
        {PizzaSize.Medium, 2.00m },
        {PizzaSize.Large, 3.25m },
        {PizzaSize.XLarge, 4.50m }
    };

然后使用一个简单的解析器来判断是非（答案是正确的）：

 private static bool TryParseTrueFalse(string answer, out bool response)
 {
     if (new[] { "Y", "Yes", "T", "True" }.Contains(answer, StringComparer.InvariantCultureIgnoreCase))
     {
         response = true;
         return true;
     }

     if (new[] { "N", "No", "F", "False" }.Contains(answer, StringComparer.InvariantCultureIgnoreCase))
     {
         response = false;
         return true;
     }

     response = false;
     return false;
 }

最后，是一个将所有内容放在一起的函数。请注意，这根本没有循环（除了如果用户回答错误的问题而循环，还可以）：

public static void GetPizza()
{
    var pizzaSizesString = string.Join(", ", Enum.GetNames(typeof(PizzaSize)));
    Console.WriteLine($"Pizza sizes: {pizzaSizesString}");
    Console.Write("Enter the size of the pizza you want: ");
    PizzaSize pizzaSize = PizzaSize.Small;
    bool answerOk = false;
    while (!answerOk)
    {
        var size = Console.ReadLine();
        answerOk = Enum.TryParse(size, out pizzaSize);
        if (!answerOk)
        {
            Console.Write(@"Please enter one of: {pizzaSizesString}");
        }
    }
    Console.Write("Would you like extra toppings on that (true/false): ");
    bool toppings = false;
    answerOk = false;
    while (!answerOk)
    {
        var toppingsString= Console.ReadLine();
        answerOk = TryParseTrueFalse(toppingsString, out toppings);
        if (!answerOk)
        {
            Console.Write(@"Please enter true or false: ");
        }
    }

    var toppingNote = toppings ? " with extra toppings" : string.Empty;
    var price = PizzaPrices[pizzaSize];
    if (toppings)
    {
        price += ToppingsPrices[pizzaSize];
    }
    Console.WriteLine($"You ordered a {pizzaSize} pizza{toppingNote} for a total of {price}");
    Console.ReadLine();
}

尝试访问并行数组中的索引时如何避免遍历整个数组

4 个答案: