Skip to main content
Engineering LibreTexts

7.1: Conditionals

  • Page ID
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    \( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

    ( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\id}{\mathrm{id}}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\kernel}{\mathrm{null}\,}\)

    \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\)

    \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\)

    \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    \( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

    \( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

    \( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vectorC}[1]{\textbf{#1}} \)

    \( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

    \( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

    \( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

    \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    C uses a fairly standard if/else construct for basic conditionals. They may be nested and each portion may consist of several statements. The condition itself may have multiple elements and be formed in either positive or negative logic. The basic construct is:

    if( test condition(s)... )
        // stuff...

    The else portion is optional and looks like:

    if( test condition(s).. )
        // stuff...
    } else
        // other stuff...

    If there is only a single statement in the block (i.e., between the braces), the braces may be removed if desired:

    if( test condition(s).. )
        //...single statement...
        // other statement...

    The test condition may check for numerous possibilities. The operators are:

    Table \(\PageIndex{1}\): Relational operators.
    == equality
    != inequality
    > greater than
    < less than
    >= greater than or equal to
    <= less than or equal to

    It is very important to note that equality uses a double equal sign. A single equal sign is an assignment operation. Don’t think “equals”, think “same as”, with one symbol for each word. You may also use Boolean (logic) operators, as shown in Table \(\PageIndex{2}\).

    Table \(\PageIndex{2}\): Logical operators.
    || OR
    && AND
    ! NOT

    Note that the logical operators do not behave the same as the similarly named bitwise operators. For example, a logical AND returns TRUE if its two arguments are non-zero, not necessarily the same bits. That is 1 & 2 yields 0, but 1 && 2 yields TRUE. TRUE is taken to be any non-zero value. Any variable or expression that evaluates to a value other than zero is logically TRUE. If the result is zero, then it is logically FALSE. Time for some examples. The conditional is written as a fragment with an explanation following:

    if( a==6 )
        /* taken only if the variable a is a 6 */
    if( b!=7 )
        /* taken as long as the variable b isn’t 7 */
    if( (a==6) && (b!=7) )
        /* taken as long as a is 6 and b is something other than 7 */
    if( (a==6) || (b!=7) )
        /* taken as long as a is 6 or b is something other than 7 */
    if( a==0 )
        /* taken if a is zero */
    if( !a )
        /* another way of saying taken if a is zero */
    if( a!=0 )
        /* taken if a is not zero */
    if( a )
        /* another way of saying taken if a is not zero */

    How you word something is up to you. The following two code fragments are equivalent:

    if( a==b )
    if( a!=b )

    It is very common for new programmers to use = when they want ==. This can have disastrous results. Consider the following code fragment:

    if( a=b )

    What does this do? At first glance, you might think it tests to see if a and b are the same. It does nothing of the kind! Instead, it assigns the value of b to a and then checks to see if that value is non-zero. In other words, it does this:

    if( a )

    A trick to help you with this, at least with constants, is to reverse the normal order. Instead of writing if( a==6 ), use if( 6==a ). This way, if you accidentally use a single equal sign, the compiler will cough up a syntax error.

    This page titled 7.1: Conditionals is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by James M. Fiore via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.

    • Was this article helpful?