{"id":914,"date":"2024-08-09T20:16:50","date_gmt":"2024-08-09T20:16:50","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=914"},"modified":"2025-01-25T21:05:22","modified_gmt":"2025-01-25T21:05:22","slug":"the-basics-of-c-c","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/beginnings\/the-basics-of-c-c\/","title":{"rendered":"The Basics of C & C++"},"content":{"rendered":"\n

<\/span>“Hello World”<\/span><\/h2>\n\n\n\n

Here’s the famous first C\/C++ program: “Hello World!”<\/p>\n\n\n\n

\n
\n
\n
<\/path><\/path><\/svg><\/span>
#include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"Hello world!<\/span>\\n<\/span>"<\/span>);<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
It prints:<\/p>\n\n\n\n
Hello world!<\/code><\/pre>\n\n\n\n
followed by a newline.<\/p>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
\n
\n
NOTE: This is old-style C I\/O. <\/p>\n\n\n\n
C++ has a better way – more later.<\/p>\n<\/blockquote>\n<\/div>\n\n\n\n
Here’s a slightly more complex program:<\/p>\n\n\n\n
\n
\n
\n
<\/path><\/path><\/svg><\/span>
#include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> total = <\/span>0<\/span>;<\/span><\/span>\n  <\/span>int<\/span> i;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; i < <\/span>10<\/span>; i++)<\/span><\/span>\n  {<\/span><\/span>\n    total = total + i;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>printf<\/span>(<\/span>"Total = <\/span>%d<\/span>\\n<\/span>"<\/span>, total);<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
which adds up all the numbers between 0 and 9 (inclusive), and then outputs the result:<\/p>\n\n\n\n
Total = 45<\/code><\/pre>\n\n\n\n
followed by a newline.<\/p>\n<\/div>\n\n\n\n
\n
<\/span>#include, main, Function Body, etc.<\/span><\/h3>\n\n\n\n
    \n
  • #include — a preprocessor directive.<\/em><\/li>\n\n\n\n
  • int main() { \u2026 } — a function definition<\/em> (in this case, the main entry point<\/em> for the program).<\/li>\n\n\n\n
  • { \u2026 } — the function body<\/em>; a block.<\/em><\/li>\n\n\n\n
  • int total = 0; — a variable definition, with an initializer.<\/li>\n\n\n\n
  • for (\u2026) { \u2026 } — a for loop<\/em>, containing a body<\/em> (block).<\/li>\n\n\n\n
  • printf(\u2026); — a call to the system-supplied printf<\/em> function, supplying two arguments: the format string<\/em>, and a parameter<\/em> to be inserted into that string.<\/li>\n\n\n\n
  • return 0; — a return<\/em> statement, returning a value from the function.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Declarations, Definitions, Statements, Expressions, Literals, & Variables<\/span><\/h2>\n\n\n\n
    \n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    #include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> total = <\/span>0<\/span>;<\/span><\/span>\n  <\/span>int<\/span> i;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; i < <\/span>10<\/span>; i++)<\/span><\/span>\n  {<\/span><\/span>\n    total = total + i;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>printf<\/span>(<\/span>"Total = <\/span>%d<\/span>\\n<\/span>"<\/span>, total);<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Within the main function body, you can see:<\/p>\n\n\n\n
    declarations\/definitions<\/em>, such as: <\/p>\n\n\n\n
    int i;<\/code><\/pre>\n\n\n\n
    statements, such as:<\/p>\n\n\n\n
    for (\u2026) { \u2026 }\nprintf(\u2026);\ntotal = total + i;\nreturn 0;<\/code><\/pre>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
    Statements and declarations\/definitions are terminated by a semicolon<\/em> (except for those ending with blocks).<\/p>\n\n\n\n
    \n
    \n
    You can also see expressions<\/em>:<\/p>\n\n\n\n
    i = 0\ni < 10\ni++\n0<\/code><\/pre>\n<\/div>\n\n\n\n
    \n
    This program uses:<\/p>\n\n\n\n
    literals<\/em>:<\/p>\n\n\n\n
    0 -- a numeric literal<\/em>\n10 -- another numeric literal<\/em>\n\"Total = %d\\n\" -- a string literal<\/em><\/code><\/pre>\n\n\n\n
    variables<\/em>:<\/p>\n\n\n\n
    total -- a variable of type int<\/em> (integer)\ni -- a variable of type int<\/em> (integer)<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Comments<\/span><\/h3>\n\n\n\n
    \n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    #include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\n\/* sum.cpp<\/span><\/span>\n<\/span>\n   A program to sum the numbers 0-9<\/span><\/span>\n<\/span>\n*\/<\/span><\/span>\nint<\/span> <\/span>main<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> total = <\/span>0<\/span>;<\/span> \/\/ Holds result<\/span><\/span>\n  <\/span>int<\/span> i;<\/span>         \/\/ Loop index<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Loop from 0-9, inclusive<\/span><\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; i < <\/span>10<\/span>; i++)<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ Add next value<\/span><\/span>\n    total = total + i;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  \/\/ Print result<\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"Total = <\/span>%d<\/span>\\n<\/span>"<\/span>, total);<\/span><\/span>\n<\/span>\n  \/\/ Return success status<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Comments<\/em> can be:<\/p>\n\n\n\n
      \n
    • \/* \u2026 *\/ , potentially over several lines.<\/li>\n\n\n\n
    • \/\/ \u2026 , until end of current line.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n\n\n\n
      <\/span>Data Types<\/span><\/h3>\n\n\n\n
      Variables in C\/C++ must be declared as having a data type<\/em>.  Here are your choices:<\/p>\n\n\n\n
      \n
      \n
      <\/path><\/path><\/svg><\/span>
      char<\/span> \/\/ an individual character,or a "tiny" integer<\/span><\/span>\nshort<\/span> \/\/ a small integer<\/span><\/span>\nint<\/span> \/\/ an integer<\/span><\/span>\nlong<\/span> \/\/ a larger integer<\/span><\/span>\nlong<\/span> <\/span>long<\/span> \/\/ an even larger integer<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
      <\/path><\/path><\/svg><\/span>
      float<\/span> \/\/ single precision floating point\u00a0<\/span><\/span>\ndouble<\/span> \/\/ double precision floating point<\/span><\/span>\nlong<\/span> <\/span>double<\/span> \/\/ extended precision floating point<\/span><\/span>\nbool<\/span> \/\/ Boolean value (true or false) (C++ only)<\/span><\/span>\nwchar_t<\/span> \/\/ wide character<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
      Integers may be signed (the default) or unsigned (a modifier)<\/p>\n\n\n\n
      <\/span>Numeric Literals<\/span><\/h3>\n\n\n\n
      \n
      \n
      Examples of Integer Literals<\/em>:<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      20<\/span> \/\/ decimal<\/span><\/span>\n024<\/span> \/\/ octal (indicated by a leading 0)<\/span><\/span>\n0x14<\/span> \/\/ hexadecimal (indicated by a leading 0x or 0X)<\/span><\/span>\n128u<\/span> \/\/ unsigned integer literal<\/span><\/span>\n1024Ul<\/span> \/\/ unsigned long literal (that's a lowercase 'l' -- prefer 'L')<\/span><\/span>\n-<\/span>1L<\/span> \/\/ long literal<\/span><\/span>\n+<\/span>8Lu<\/span> \/\/ unsigned long literal<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
      Examples of Floating Point Literals:<\/em><\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      3.14159<\/span> \/\/ double precision floating point<\/span><\/span>\n3.14159F<\/span> \/\/ single precision floating point (use trailing 'F' or 'f')<\/span><\/span>\n3.14159L<\/span> \/\/ extended precision floating point (use trailing 'L' or 'l')<\/span><\/span>\n3e1<\/span> \/\/ double precision floating point, scientific notation<\/span><\/span>\n1.0E-3F<\/span> \/\/ single precision floating point, scientific notation<\/span><\/span>\n-<\/span>0.34e+5L<\/span> \/\/ extended precision floating point, scientific notation<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
      <\/span>String and Character Literals<\/span><\/h3>\n\n\n\n
      Character literals<\/em><\/strong> can consist of a single character<\/em>, and are enclosed within single quotes<\/em> (apostrophes: ‘):<\/p>\n\n\n\n
      'a' ; '5' ; ',' ; '\"' ; ' ' (space)<\/code><\/pre>\n\n\n\n
      Strings are simply arrays of characters<\/em> in C;  they are not first-class data types<\/em>.
      String literals<\/em><\/strong> can consist of zero or more characters<\/em>, and are enclosed within double quotes<\/em>:<\/p>\n\n\n\n
      \"Bryan\" ; \"C++ Programming\" ; \" - \/ $ \" ; \"\" (null string)<\/code><\/pre>\n\n\n\n
      Wide-character literals<\/em><\/strong> are just like regular character or string literals, except that they are preceded by an <\/em>L:<\/p>\n\n\n\n
      L'a'; L\"Bryan\"<\/code><\/pre>\n\n\n\n
      <\/span>Escape Sequences<\/span><\/h3>\n\n\n\n
      \n
      \n
      To represent non-printable<\/em> and special characters<\/em>, in string and character literals<\/em>, we use escape sequences:<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      '<\/span>\\n<\/span>'<\/span> \/\/ newline (line feed)<\/span><\/span>\n'<\/span>\\t<\/span>'<\/span> \/\/ horizontal tab<\/span><\/span>\n'<\/span>\\v<\/span>'<\/span> \/\/ vertical tab<\/span><\/span>\n'<\/span>\\b<\/span>'<\/span> \/\/ backspace<\/span><\/span>\n'<\/span>\\r<\/span>'<\/span> \/\/ carriage return<\/span><\/span>\n'<\/span>\\f<\/span>'<\/span> \/\/ form feed<\/span><\/span>\n'<\/span>\\a<\/span>'<\/span> \/\/ alert (bell)<\/span><\/span>\n'<\/span>\\\\<\/span>'<\/span> \/\/ backslash<\/span><\/span>\n'<\/span>\\?<\/span>'<\/span> \/\/ question mark<\/span><\/span>\n'<\/span>\\'<\/span>'<\/span> \/\/ single quote (apostrophe)<\/span><\/span>\n'<\/span>\\n<\/span>nn'<\/span> \/\/ character whose octal value is nnn (where 'n' represents an octal digit, 0-7 - up to 3 octal digits)<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
      Examples:<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      '<\/span>\\7<\/span>'<\/span> \/\/ audible bell<\/span><\/span>\n'<\/span>\\n<\/span>'<\/span> \/\/ newline (line feed)<\/span><\/span>\n'<\/span>\\0<\/span>'<\/span> \/\/ null character<\/span><\/span>\n'<\/span>\\062<\/span>'<\/span> \/\/ ASCII value of character 2<\/span><\/span>\n'<\/span>\\t<\/span>'<\/span> \/\/ horizontal tab<\/span><\/span>\n"<\/span>\\\\<\/span>Hello<\/span>\\\\<\/span>, <\/span>\\"<\/span>World<\/span>\\"<\/span>!<\/span>\\n<\/span>"<\/span> <\/span><\/span>\n         \/\/ \\Hello\\, "World"! followed by newline<\/span><\/span>\n'<\/span>\\'<\/span>'<\/span> \/\/ single quote character<\/span><\/span>\n"Hello, \\<\/span><\/span>\nCruel World!<\/span>\\n<\/span>"<\/span> <\/span><\/span>\n         \/\/ continue string literal onto next line<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
      <\/span>Boolean Literals<\/span><\/h3>\n\n\n\n
      Variables of type bool can take one of two literal values:<\/p>\n\n\n\n
      true\nfalse<\/code><\/pre>\n\n\n\n
      For example:<\/p>\n\n\n\n
      bool running = true;\nwhile (running)\n{\n  \/\/ \u2026\n  if (areDone())\n  {\n    running = false; \/\/ cause loop to exit\n  }\n}<\/code><\/pre>\n\n\n\n
      <\/span>Expressions, Operands, & Operators<\/span><\/h3>\n\n\n\n
      An expression consists of one or more operands, and (optionally) an operation to be applied to them:<\/p>\n\n\n\n
      53\t\t        \/\/ (a numeric literal is a simple expression)\nhorsefeathers.  \/\/ (a variable name is a simple expression)\nsalary + raise\nsale_price * discount\n\"Fred \" + \"Bloggs \" + \" Jr.\"\n<\/code><\/pre>\n\n\n\n
      <\/span>Arithmetic Operators<\/span><\/h3>\n\n\n\n
      \n
      \n
      The Arithmetic Operators<\/em> are:<\/p>\n\n\n\n
        \n
      • expr1 <\/em>*<\/strong> <\/em><\/strong>expr<\/em>2 — multiplication<\/li>\n\n\n\n
      • expr1 <\/em>\/<\/strong> expr<\/em>2 — division<\/li>\n\n\n\n
      • expr1 <\/em>%<\/strong> expr<\/em>2 — remainder (modulus)<\/li>\n\n\n\n
      • expr1 <\/em>+<\/strong> expr<\/em>2 — addition<\/li>\n\n\n\n
      • expr1 <\/em>–<\/strong> expr<\/em>2 — subtraction<\/li>\n<\/ul>\n<\/div>\n\n\n\n
        \n
        Division between integers<\/em> results in an integer, with any fractional part truncated.<\/p>\n\n\n\n
        The modulus operator<\/em> operator may only be applied to two integers (a%b), and returns the remainder from the division a\/b.  [Note: This is well defined only if both operands are positive.]<\/em><\/p>\n<\/div>\n<\/div>\n\n\n\n
        <\/span>Autoincrement & Autodecrement Operators<\/span><\/h3>\n\n\n\n
        \n
        \n
        The AutoIncrement Operators<\/em> are:<\/p>\n\n\n\n
          \n
        • ++lvalue<\/em><\/strong> — pre-increment<\/li>\n\n\n\n
        • lvalue<\/em>++<\/strong> — post-increment<\/li>\n<\/ul>\n\n\n\n
          The Autodecrement Operators<\/em> are:<\/p>\n\n\n\n
            \n
          • —lvalue<\/em><\/strong> — pre-decrement<\/li>\n\n\n\n
          • lvalue<\/em>—<\/strong> — post-decrement<\/li>\n<\/ul>\n<\/div>\n\n\n\n
            \n
            The operators ++ and \u2212\u2212 can be used as both prefix and postfix operators. The value of ++x is the new (that is, incremented) value of x. For example, y=++x is equivalent to y=(x=x+1). The value of x++, however, is the old value of x. For example, y=x++ is equivalent to y=(t=x, x=x+1, t), where t is a variable of the same type as x.<\/p>\n\n\n\n
            Decrementing is similarly expressed by the \u2212\u2212 operator.<\/p>\n\n\n\n
            The ++ operator is used to express incrementing directly, rather than expressing it indirectly using a combination of an addition and an assignment. Provided lvalue has no side effects, ++lvalue means lvalue+=1, which again means lvalue=lvalue+1. The expression denoting the object to be incremented is evaluated once (only).<\/p>\n<\/div>\n<\/div>\n\n\n\n
            <\/span>Equality & Relational Operators<\/span><\/h3>\n\n\n\n
            The Equality Operators<\/em> are:<\/p>\n\n\n\n
              \n
            • expr1 <\/em>==<\/strong> expr<\/em>2 — is equal to (Note the common mistake of typing <\/em>= !  :  (expr1 = expr2) is NOT the same as (expr1 == expr2))<\/em><\/strong><\/li>\n\n\n\n
            • expr1 <\/em>!=<\/strong> expr<\/em>2 — is not equal to<\/li>\n<\/ul>\n\n\n\n
              The Relational Operators<\/em> are:<\/p>\n\n\n\n
                \n
              • expr1 <\/em><<\/strong> expr<\/em>2 — is less than<\/li>\n\n\n\n
              • expr1 <\/em>><\/strong> expr<\/em>2 — is greater than<\/li>\n\n\n\n
              • expr1 <\/em><=<\/strong> expr<\/em>2 — is less than or equal to<\/li>\n\n\n\n
              • expr1 <\/em>>=<\/strong> expr<\/em>2 — is greater than or equal to<\/li>\n<\/ul>\n\n\n\n
                <\/span>Logical & Bitwise Operators<\/span><\/h3>\n\n\n\n
                The Logical Operators<\/em> are:<\/p>\n\n\n\n
                  \n
                • expr1 <\/em>&&<\/strong> expr<\/em>2 — Logical AND<\/li>\n\n\n\n
                • expr1 <\/em>||<\/strong> expr<\/em>2 — Logical OR<\/li>\n\n\n\n
                • !<\/strong> expr<\/em> — Logical NOT<\/li>\n<\/ul>\n\n\n\n
                  The Bitwise Operators<\/em> are:<\/p>\n\n\n\n
                    \n
                  • expr1 <\/em>&<\/strong> expr<\/em>2 — Bitwise AND<\/li>\n\n\n\n
                  • expr1 <\/em>|<\/strong> expr<\/em>2 — Bitwise OR<\/li>\n\n\n\n
                  • expr1 <\/em>^<\/strong> expr<\/em>2 — Bitwise XOR<\/li>\n<\/ul>\n\n\n\n
                    <\/span>Simple Statements<\/span><\/h3>\n\n\n\n
                    An Expression Statement<\/em> is:<\/p>\n\n\n\n
                      \n
                    • expr<\/em>;<\/li>\n<\/ul>\n\n\n\n
                      or:<\/p>\n\n\n\n
                        \n
                      • ; (the null statement<\/em>)<\/li>\n<\/ul>\n\n\n\n
                        Examples of Expression Statements<\/em>:<\/p>\n\n\n\n
                        42 ; \/\/ expression result\/value is discarded\nanna + kingOfSiam; \/\/ value of expression discarded\n; \/\/ null statement\nx = y * z; \/\/ Remember, in C\/C++, = is an operator\nprintf(\"Hello!\"); \/\/ any value returned by the function is discarded<\/code><\/pre>\n\n\n\n
                        <\/span>Compound (Block) Statements<\/span><\/h2>\n\n\n\n
                        A Compound Statement<\/em> (also known as a block<\/em>) is a sequence of zero or more statements enclosed within curly braces<\/em> ({\u2026})<\/p>\n\n\n\n
                        For example:<\/p>\n\n\n\n
                        {
                        int value = readFromUser();
                        writeOut( process(value) );
                        }<\/code><\/pre>\n\n\n\n
                        <\/span>if Statements<\/span><\/h3>\n\n\n\n
                        An if statement<\/em> has the following forms:<\/p>\n\n\n\n
                        if (<\/strong>condition<\/em><\/strong>)<\/strong>\n  <\/strong>statement<\/em><\/strong><\/code><\/pre>\n\n\n\n
                        or:<\/p>\n\n\n\n
                        if (condition)\n  statement\nelse\n  statement<\/strong><\/code><\/pre>\n\n\n\n
                        Note that the parentheses around the condition are required<\/em>.<\/p>\n\n\n\n
                        Example:<\/p>\n\n\n\n
                        if (x == y)\n  printf(\"x and y are equal\\n\");<\/code><\/pre>\n\n\n\n
                        <\/span>switch Statements<\/span><\/h3>\n\n\n\n
                        \n
                        \n
                        A switch statement<\/em> has the form:<\/p>\n\n\n\n
                        switch (condition)\n{\n\tcase constant-expression :\n\t\tstatement\n\t. . .\n\tdefault :\t\/\/ Optional\n\t\tstatement\n}<\/strong><\/code><\/pre>\n<\/div>\n\n\n\n
                        \n
                        Example:<\/p>\n\n\n\n
                        <\/path><\/path><\/svg><\/span>
                        switch<\/span> (color)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>case<\/span> black:<\/span><\/span>\n\t\t<\/span>printf<\/span>(<\/span>"black"<\/span>);<\/span><\/span>\n\t\t<\/span>break<\/span>;<\/span><\/span>\n\t<\/span>case<\/span> green:<\/span><\/span>\n\t\t<\/span>printf<\/span>(<\/span>"green"<\/span>);\t\t<\/span>break<\/span>;<\/span><\/span>\n\t<\/span>default<\/span>:<\/span><\/span>\n\t\t<\/span>printf<\/span>(<\/span>"no color"<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                        <\/span>Loops (Iteration Statements)<\/span><\/h3>\n\n\n\n
                        \n
                        \n
                        Loops come in four forms:<\/p>\n\n\n\n
                          \n
                        • while<\/strong> statement (pre-tested):<\/li>\n<\/ul>\n\n\n\n
                          while (condition)\n<\/strong>  statement<\/strong><\/code><\/pre>\n\n\n\n
                            \n
                          • do<\/strong> statement (post-tested) — error-prone; not usually recommended:<\/em><\/li>\n<\/ul>\n\n\n\n
                            do \n  statement \nwhile (expression<\/em>)<\/strong><\/code><\/pre>\n\n\n\n
                              \n
                            • for<\/strong> statement:<\/li>\n<\/ul>\n\n\n\n
                              for ( init; condition; iterate-expr )\n  statement<\/strong><\/code><\/pre>\n\n\n\n
                                \n
                              • range-for statement (since C++11):<\/li>\n<\/ul>\n\n\n\n
                                for (for-declaration : expression)\n  statement<\/strong><\/code><\/pre>\n<\/div>\n\n\n\n
                                \n
                                Examples:<\/p>\n\n\n\n
                                <\/path><\/path><\/svg><\/span>
                                while<\/span> (is-<\/span>true<\/span>)<\/span><\/span>\n  <\/span>dosomething<\/span>();<\/span><\/span>\n  <\/span><\/span>\ndo<\/span><\/span>\n  <\/span>dosomething<\/span>()<\/span><\/span>\nwhile<\/span> (until-<\/span>false<\/span>);<\/span><\/span>\n<\/span>\nfor<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < <\/span>10<\/span>; i++)<\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"<\/span>%d<\/span> "<\/span>, i);<\/span><\/span>\n<\/span>\nint<\/span> a[] = {<\/span>0<\/span>, <\/span>1<\/span>, <\/span>2<\/span>, <\/span>3<\/span>, <\/span>4<\/span>, <\/span>5<\/span>};<\/span><\/span>\nfor<\/span> (<\/span>int<\/span> n : a) <\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"<\/span>%d<\/span> "<\/span>, n);<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
                                <\/span>break, continue, & goto<\/span><\/h3>\n\n\n\n
                                \n
                                \n
                                A break<\/strong> statement, inside a loop, causes loop termination.<\/p>\n\n\n\n
                                A continue<\/strong> statement, inside a loop, causes the loop to go to the next iteration.<\/p>\n\n\n\n
                                A goto<\/strong> statement transfers control to the statement identified by the specified label:<\/p>\n\n\n\n
                                goto whereever;<\/strong><\/code><\/pre>\n\n\n\n
                                \n
                                Note:<\/strong> Do not use goto<\/strong>, except when you have absolutely no alternative.  Even then, think again!<\/em><\/p>\n<\/blockquote>\n\n\n\n
                                A return<\/strong> statement returns a value from its enclosing function, to the function’s caller:<\/p>\n\n\n\n
                                return 5 * currentPay;<\/strong><\/code><\/pre>\n<\/div>\n\n\n\n
                                <\/div>\n<\/div>\n\n\n\n
                                <\/span>Functions<\/span><\/h2>\n\n\n\n
                                Functions come in the following flavors:<\/p>\n\n\n\n
                                  \n
                                • Functions provided by the compiler environment\/system<\/li>\n<\/ul>\n\n\n\n
                                  printf, scanf, exec, & lots more\u2026<\/code><\/pre>\n\n\n\n
                                    \n
                                  • Functions provided by some other organization\n
                                      \n
                                    • Third party software vendors<\/li>\n\n\n\n
                                    • Your own organization, or others within the same company<\/li>\n\n\n\n
                                    • Others<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                        \n
                                      • Functions written by you<\/li>\n<\/ul>\n\n\n\n
                                        <\/span>Function Declarations & Headers<\/span><\/h3>\n\n\n\n
                                        Whoever supplies a function is responsible for providing a well-documented interface to it.<\/p>\n\n\n\n
                                        In particular, a function should be declared in some module<\/em>, and that module should have one or more header files<\/em> defined for it.<\/p>\n\n\n\n
                                        When a function is supplied by the compiler environment, the header file is accessed using a precompiler directive<\/em> of the form:<\/p>\n\n\n\n
                                        #include <stdio.h>  \/\/ The standard I\/O header<\/strong><\/code><\/pre>\n\n\n\n
                                        where the angle brackets are a convention for “system-supplied”<\/p>\n\n\n\n
                                        Usually, when a module of functions is supplied by a third party (not the compiler environment\/vendor), corresponding header files are of the form:<\/p>\n\n\n\n
                                        #include \"byglop.h\"  \/\/ Enclosed in double quotes.<\/strong><\/code><\/pre>\n\n\n\n
                                        This is also the approach you should take with your own modules of functions.  Always provide the function interface declarations in a well-defined and well-known header file.<\/p>\n\n\n\n
                                        <\/span>Other Preprocessor Directives<\/span><\/h3>\n\n\n\n
                                        There are a number of other preprocessor directives that may be used:<\/p>\n\n\n\n
                                          \n
                                        • Macro definition:<\/li>\n<\/ul>\n\n\n\n
                                          #define PI 3.141259<\/strong>\n#define max(v1,v2) ((v1)>(v2))?(v1):(v2)<\/strong><\/code><\/pre>\n\n\n\n
                                          This is C’s approach to:<\/p>\n\n\n\n
                                            \n
                                          • Defining constants<\/li>\n\n\n\n
                                          • Optimizing certain functions so that they can be expanded inline for better performance.<\/li>\n<\/ul>\n\n\n\n
                                            Be careful with #define<\/strong>!  It is very tricky and error-prone!<\/p>\n\n\n\n
                                            \n
                                            C++ has implemented better solutions for most of the preprocessor directives <\/p>\n<\/blockquote>\n\n\n\n
                                            Here’s another useful set of directives:<\/p>\n\n\n\n
                                              \n
                                            • Conditional compilation:<\/li>\n<\/ul>\n\n\n\n
                                              #ifdef MSDOS<\/strong>\n\/\/ Do whatever one needs to do for MS-DOS support<\/strong>\n#endif<\/strong><\/code><\/pre>\n\n\n\n
                                              \n
                                              There is a very important usage of this, known as a guard<\/em>.  It prevents multiple includes of a header file from messing up a compilation.  Here’s an example skeleton header file that uses a guard:<\/p>\n<\/blockquote>\n\n\n\n
                                              #ifndef FRAG_H\n#define FRAG_H \/\/ It doesn't matter what it's defined to.\n\n  \/\/ Header file contents go here\n\n#endif FRAG_H<\/strong><\/code><\/pre>\n\n\n\n
                                              \n
                                              Conditional compilation is often used to create a debug version of a program.<\/p>\n<\/blockquote>\n\n\n\n
                                              <\/span>End of Whirlwind Tour<\/span><\/h2>\n\n\n\n
                                              This was an attempt to give you a very fast “leg-up” on learning the basics of C\/C++.<\/p>\n\n\n\n
                                              Don’t expect to know everything about these languages at this point!  There’s so much more to understand, and we’ll be learning much more through the rest of the course.<\/p>\n\n\n\n
                                              Onward!<\/p>\n\n\n\n
                                              <\/p>\n","protected":false},"excerpt":{"rendered":"
                                              “Hello World” Here’s the famous first C\/C++ program: “Hello World!” It prints: followed by a newline. NOTE: This is old-style C I\/O. C++ has a better way – more later. Here’s a slightly more complex program: which adds up all the numbers between 0 and 9 (inclusive), and then outputs the result: followed by a […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1871,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-914","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/914","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=914"}],"version-history":[{"count":41,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/914\/revisions"}],"predecessor-version":[{"id":1672,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/914\/revisions\/1672"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1871"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=914"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}