Don't understand this block of code(it runs with no condition)
<p>I'm learning c++ and haven't really seen this in any of the books I've read. I wanted to read and comment code so I can learn better and came across a odd section of code that runs but does not have a condition. From what I read(and my experiences with other languages, you need an if, while,for or something for blocks).  </p>

<p>I'm looking at the tbb threads package so I'm not sure if its related to launching threads or c++ specific(if you don't recognize this as something common in c++ then its probably tdd specific).</p>

<p>I think I understand what the code inside actually does but I'm not sure how its being triggered or ran. Any ideas? </p>

<p>Here's the section:</p>

<pre><code>    {
        //this is the graph part of the code
        Graph g;
        g.create_random_dag(nodes);
        std::vector&lt;Cell*&gt; root_set;
        g.get_root_set(root_set);
        root_set_size = root_set.size();
        for( unsigned int trial=0; trial&lt;traversals; ++trial ) {
            ParallelPreorderTraversal(root_set);
        }
    }
</code></pre>

<p>p.s. If it helps here's the entire file(the above code is in the middle of the main()).</p>

<pre><code>#include &lt;cstdlib&gt;
#include "tbb/task_scheduler_init.h"
#include "tbb/tick_count.h"
#include "../../common/utility/utility.h"
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include "Graph.h"

// some forward declarations
class Cell;
void ParallelPreorderTraversal( const std::vector&lt;Cell*&gt;&amp; root_set );

//------------------------------------------------------------------------
// Test driver
//------------------------------------------------------------------------
utility::thread_number_range threads(tbb::task_scheduler_init::default_num_threads);
static unsigned nodes = 1000;
static unsigned traversals = 500;
static bool SilentFlag = false;

//! Parse the command line.
static void ParseCommandLine( int argc, const char* argv[] ) {
    utility::parse_cli_arguments(
            argc,argv,
            utility::cli_argument_pack()
                //"-h" option for for displaying help is present implicitly
                .positional_arg(threads,"n-of-threads","number of threads to use; a range of the form low[:high], where low and optional high are non-negative integers or 'auto' for the TBB default.")
                .positional_arg(nodes,"n-of-nodes","number of nodes in the graph.")
                .positional_arg(traversals,"n-of-traversals","number of times to evaluate the graph. Reduce it (e.g. to 100) to shorten example run time\n")
                .arg(SilentFlag,"silent","no output except elapsed time ")
    );
}

int main( int argc, const char* argv[] ) {
    try {
        tbb::tick_count main_start = tbb::tick_count::now(); //tbb counter start
        ParseCommandLine(argc,argv);

        // Start scheduler with given number of threads.
        std::cout &lt;&lt; threads &lt;&lt; std::endl;
        for( int p=threads.first; p&lt;=threads.last; ++p ) {
            tbb::tick_count t0 = tbb::tick_count::now(); //timer
            tbb::task_scheduler_init init(4); //creates P number of threads
            srand(2); //generates a random number between 0-2?
            size_t root_set_size = 0; 
            {
                //this is the graph part of the code
                Graph g;
                g.create_random_dag(nodes);
                std::vector&lt;Cell*&gt; root_set;
                g.get_root_set(root_set);
                root_set_size = root_set.size();
                for( unsigned int trial=0; trial&lt;traversals; ++trial ) {
                    ParallelPreorderTraversal(root_set);
                }
            }
            tbb::tick_count::interval_t interval = tbb::tick_count::now()-t0; //counter done
            if (!SilentFlag){ //output the results
                std::cout
                    &lt;&lt;interval.seconds()&lt;&lt;" seconds using "&lt;&lt;p&lt;&lt;" threads ("&lt;&lt;root_set_size&lt;&lt;" nodes in root_set)\n";
            }
        }
        utility::report_elapsed_time((tbb::tick_count::now()-main_start).seconds());

        return 0;
    }catch(std::exception&amp; e){
        std::cerr
            &lt;&lt; "unexpected error occurred. \n"
            &lt;&lt; "error description: "&lt;&lt;e.what()&lt;&lt;std::endl;
        return -1;
    }
}
</code></pre>
