Welcome to the Lounge

CDP1802 wrote:

Under the hood almost every code block that is put into curly brackets is
implemented with machine instructions for conditional or unconditional branches.
GOTOs, if you want. They have just been hidden away.

harold aptroot wrote:

The Hivemind, ever hypocritical, also suggests refucktoring "nested loops where
you exit both of them from the inner loop" to a confusingly-named and
nonsensical-on-its-own function with multiple returns, a practice that it itself also denounces.

Tarek Elqusi wrote:

Troubles are based on the programmer who is misusing it

altomaltes wrote:

your exit from work will be no too structured

// Some code here.  Entering a section with lots of error checking.

do
{
    // Some code goes here that sets an error condition.

    if (error)
    {
        break;
    }

    // Some more code that sets an error condition.

    if (error)
    {
        break;
    }

    // Even more code that sets an error condition.

    if (error)
    {
        break;
    }

    // etc.
}
while (false);

// The code continues here.

// Some code here.  Entering a section with lots of error checking.
// Some code goes here that sets an error condition.
if (!error)
{
   // Some more code that sets an error condition.
   if (!error)
   {
      // Even more code that sets an error condition.
      if (!error)
      {
         // etc.
      }
   }
}
// The code continues here.

// Some code here.  Entering a section with lots of error checking.
// Some code goes here that sets an error condition.
if (error)
{
   // Report error details here.
}
else
{
   // Some more code that sets an error condition.
   if (error)
   {
      // Report error details here.
   }
   else
   {
      // Even more code that sets an error condition.
      if (error)
      {
         // Report error details here.
      }
      else
      {
         // etc.
      }
   }
}
// The code continues here.

    public int CompareTo(ComparableTuple8<TItem0, TItem1, TItem2, TItem3, TItem4, TItem5, TItem6, TItem7> group)
    {
        int result = this.Item0.CompareTo(group.Item0);

        if (result == 0)
        {
            result = this.Item1.CompareTo(group.Item1);

            if (result == 0)
            {
                result = this.Item2.CompareTo(group.Item2);

                if (result == 0)
                {
                    result = this.Item3.CompareTo(group.Item3);

                    if (result == 0)
                    {
                        result = this.Item4.CompareTo(group.Item4);

                        if (result == 0)
                        {
                            result = this.Item5.CompareTo(group.Item5);

                            if (result == 0)
                            {
                                result = this.Item6.CompareTo(group.Item6);

                                if (result == 0)
                                {
                                    result = this.Item7.CompareTo(group.Item7);
                                }
                            }
                        }
                    }
                }
            }
        }

        return result;
    }

    #endregion
}

template <typename T, typename... Args>
class Tuple : public Tuple<Args...>
{
    // ...
};

#include <tuple>
#include <iostream>

int main()
{
	auto t1 = std::make_tuple(1, 2, 3, 4, 5);
	auto t2 = std::make_tuple(1, 2, 3, 4, 6);

	if (t1 < t2)
		std::cout << "Less" << std::endl;
	else if (t1 > t2)
		std::cout << "Greater" << std::endl;
	else
		std::cout << "Equal" << std::endl;

	return 0;
}

int main()
{
    std::cout << "Less" << std::endl;
}