Question

有没有人知道嵌套条件的限制（我指的是另一个条件，几次）？在，比方说，Java和Visual Basic。

我记得当我开始使用我的开发跟踪时，我认为，我认为VB 6中的3个嵌套条件和编译器，只是没有进入第三个，现在我记得我从来没有，知道最大的嵌套语言可以采用的编码。

Answer 1

REAL编程语言不应存在限制。对于VB.NET和Java，如果有任何限制，我会感到震惊。限制不是内存，因为我们讨论的是COMPILE TIME约束，而不是执行环境约束。

这可以在C＃中找到：应该注意的是编译器可能会优化它甚至不使用IF。

static void Main(string[] args)
{
    if (true)
    {
        if (true)
        {
            if (true)
            {
                if (true)
                {
                    if (true)
                    {
                        if (true)
                        {
                            if (true)
                            {
                                if (true)
                                {
                                    if (true)
                                    {
                                        if (true)
                                        {
                                            if (true)
                                            {
                                                if (true)
                                                {
                                                    if (true)
                                                    {
                                                        if (true)
                                                        { Console.WriteLine("It works"); }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

这不应该过分优化：

static void Main(string[] args)
{
    if (DateTime.Now.Month == 1)
    {
        if (DateTime.Now.Year == 2011)
        {
            if (DateTime.Now.Month == 1)
            {
                if (DateTime.Now.Year == 2011)
                {
                    if (DateTime.Now.Month == 1)
                    {
                        if (DateTime.Now.Year == 2011)
                        {
                            if (DateTime.Now.Month == 1)
                            {
                                if (DateTime.Now.Year == 2011)
                                {
                                    if (DateTime.Now.Month == 1)
                                    {
                                        if (DateTime.Now.Year == 2011)
                                        {
                                            if (DateTime.Now.Month == 1)
                                            {
                                                if (DateTime.Now.Year == 2011)
                                                {
                                                    if (DateTime.Now.Month == 1)
                                                    {
                                                        if (DateTime.Now.Year == 2011)
                                                        { Console.WriteLine("It works"); }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    Console.ReadKey();
}

Answer 2

我同意大多数人的观点，即编写if块没有限制。 但是java方法大小有一个最大限制。我相信它的64K。

Answer 3

如果你的意思是嵌套的if块，那么就没有理论上的限制。唯一的限制是用于存储源代码和/或编译代码的可用磁盘空间。如果每个块生成一个新的堆栈帧，则可能还存在运行时限制，但这又是一个内存限制。

3的经验结果的唯一解释是编程错误或解释结果时出错。

Answer 4

我必须同意限制纯粹基于内存限制。如果你达到了它，我希望你会达到某种堆栈溢出限制，但是我怀疑你是否有可能达到这个限制。

我找不到支持的参考资料来源，但快速测试了40多个嵌套的if语句编译并运行正常。

Answer 5

嵌套条件数量的限制几乎肯定会基于编译器的堆栈和数据结构的大小，而不是与运行时环境有关，除非可能在目标环境的代码空间的情况下相对于编译器可用的存储器而言受到严格限制（例如，使用现代PC为具有512字节闪存的小型微控制器编译程序）。请注意，在运行时不需要RAM（超出用于存储代码本身的任何RAM）来评估深度嵌套的逻辑运算符组合，除了最复杂的术语（即计算所需的内存）所需的任何内容。（foo（）|| bar（））＆amp;＆amp; boz（）'是计算foo（），bar（）或boz（））所需的最大内存。

实际上，在现代机器上使用现代编译器无法达到极限，除非有人为了超出它的特定目的而编写“程序”（我希望限制可能是在1,000到1,000,000级别的嵌套之间，但即使它只有“1000”，也没有理由将这些东西嵌套到深处。

Answer 6

逻辑上我认为限制将基于Java中应用程序可用的内存。

允许的最大嵌套条件数

6 个答案: