#include <iostream>

void incrementAndPrint()
{
    static int s_value{ 1 }; // static duration via static keyword.  This initializer is only executed once.
    ++s_value;
    std::cout << s_value << '\n';
} // s_value is not destroyed here, but becomes inaccessible because it goes out of scope

int main()
{
    incrementAndPrint();
    incrementAndPrint();
    incrementAndPrint();

    return 0;
}

#include <iostream>

int s_value = 1; // out of scope at start

void incrementAndPrint()
{
    // static int s_value{ 1 }; // static duration via static keyword. This initializer is only executed once.
    ++s_value;
    std::cout << s_value << '\n';
}

int main()
{
    incrementAndPrint();
    incrementAndPrint();
    incrementAndPrint();

    return 0;
}

#include <iostream>

// All non-local variables with static storage duration are initialized as part of program startup,
// before the execution of the main function begins (unless deferred)
// https://en.cppreference.com/w/cpp/language/initialization#Non-local_variables
// Deferred dynamic initialization:
// see https://en.cppreference.com/w/cpp/language/initialization#Deferred_dynamic_initialization
int g = ( ( std::cout << "initialising ::g\n" ), 100 ) ;

int dummy = 5 ;

void foo( int arg )
{
    std::cout << "foo(" << arg << ")\n" ;
    if( arg > 10 )
    {
        std::cout << "arg is greater than 10\n" ;
        // Variables declared at block scope with the specifier static are initialized the first time
        // control passes through their declaration (unless their initialization is zero- or constant-initialization
        // (unless their initialization is zero- or constant-initialization, which may be performed earlier)
        // https://en.cppreference.com/w/cpp/language/storage_duration#Static_local_variables
        [[maybe_unused]] static int s = ( ( std::cout << "initialising foo::s\n" ), 200 ) ;
    }
}

int main()
{
    // ::g may be already initialised here (initialised before the execution of the main function begins)

    foo(2) ; // foo::s is not initialised (control does not pass through its declaration)

    // ::g would definitely be initialised here (before the first odr-use of a static non-local)
    ++dummy ; // odr-use of a variable with static storage duration, defined in this translation unit

    foo(55) ; // foo::s is initialised when control passes through its declaration for the first time
}

#include <iostream>

using std::cout; //Bad?
using std::cin;  //Bad?

int main()
{
    cout << "Hello World!" << '\n';
    return 0;
}

#include <iostream>


int main()
{
    code;

    { //this represents having like 100 cin/cout statements or something where std:: would be tedious bloat
       using std::cout; //good! or at least "not bad"
       using std::cin;  //good!
       cout << "Hello World!" << '\n';
    } //using statements are deactivated here. 

    more code;
}

int main()
{
    ...
     { #include "usingiostream.h"
       cin, cout, endl, setw, whatever all activated here
     } //all expire 
    ...
}