article

Beginners C++ - Lesson 2: Variables, math and booleans

Email
Submitted on: 1/1/2015 6:58:00 AM
By: Found on the World Wide Web (from psc cd)  
Level: Beginner
User Rating: By 10 Users
Compatibility: C++ (general)
Views: 1493
 
     Learn how to do variables, math and booleans in C++! (from http://pa.pulze.com/)

 
				

Beginners C++ - Lesson 2

Instructor:   Paul C. Benedict, Jr. (PCC PaulB)

Color coded text:

    black            New things to Remember
    blue             C++ keywords (do, while)
    green           C++ preprocessor directives (#include, #define)


Section 2.1

From last time, we learned how to declare numbers and do math with them. For instance, lets declare an integer variable we call x and set it to five:

Example 2.1.1
    int x = 5;

This called initialization! We call it initialization because x was set to five when it was created (The int means create an integer variable. It is not an abbrevation for initialization). Now, if we left off the value (called the inital value), x would contain junk. What do we mean when we say it contains junk? When x was allocated (memory that was set aside for x), whatever value that was in memory previously before x is now the value of x. We call this value of x undefined because we did not define the value, and since the value is undefined, the variable is uninitialized. You cannot do anything useful with the variable until it was initialized. You do not have to initialize variables when you declare them.variable before using it.

Example 2.1.2
Here you declare two variables, then assign them later.
    int x;
    int y;
    x = 5;
    y = x * 3;

First x and y is declared (and has an undefined value because it is uninitalized). Then x is initialized to the value five. They y is initialized to the value of x times 3, which is fifteen.

Example 2.1.3
What happened if we did this?
    int x;
    x = x + 1;

What is the value of x? We don't know. x is whatever it was plus one now. The value is completely meaningless to us. One of the most common bugs in programming is not initializing variables before you use it. (On a side note, a bug is an "unlisted feature" in a program that makes the program not work they way you want it - the last example shows this.).


Section 2.2

These are the current operators we know so far from our last lesson:
    Addition                                    +
    Subtraction                                -
    Multiplication                             *
    Division                                     /
    Modular Division (Remainder)     %

We are now going to learn some more operators to work with numbers:
    Increment                                 ++
    Decrement                                --
    Addition Assignment                 +=
    Subtraction Assignment             -=
    Multiplication Assignment          *=
    Division Assignment                  /=
    Remainder Assignment             %=

Example 2.2.1
The increment operator ++  increments a variable by one.
The decrement operator --  decrements a variable by one.
    int x = 10;
    x++;
    x = x + 3;
    x--;

First x is initialized to the value ten.
Then it is incremented to the value eleven.
Next we add three to it.
Then we decrement it.
The final value for the variable x is now thirteen.

Example 2.2.2
Now, with the += operator we can simply this even more:
    int x = 10;
    x++;
    x += 3;
    x--;

Wow! Look at that!
    x += 3;
Is an equivalent shorthand for
    x = x + 3;

Example 2.2.3
So, lets see how we can reduce our typing on these next four statements:
    x = x + 1;
    x = x - 3;
    x = x * 2;
    x = x / 3;
They reduce to:
    x += 1;
    x -= 3;
    x *= 2;
    x /= 3;

The C++ makers were nice enough to save some typing for us. You will always see these shorthands in professional code, so always keep these in the back of your mind. Once you begin programming, you will become very fluent in the language and begin using it naturally.


Section 2.3

Now we are going to learn the all important assignment precedence and associativity rules. In math, do you remember the "Pretty Please My Dear Aunt Sally" (PPMDAS) phrase? That was a saying to remember the precedence rules of our operators:
    Parentheses                               Highest
    Powers
    Multiplication, Division
    Addition, Subtraction                   Lowest

Example 2.3.1
    int x = 2 + 5 * 3;

According to precedence, multiplication comes first before addition. So we multiply five and three, then add two. x now contains seventeen. We could have thrown in parentheses and got a different answer:

Example 2.3.2
    int x = (2 + 5) * 3;

Parentheses has the highest precedence here, so we do the inside of them first. Two plus five is seven, then we multiply by three and get twenty-one.

In C++, there are many other operators we must deal with. We will introduce two other operators to you (one which you should already be familiar with). We have the = operator (which we call the assignment operator), and we have the == operator (which we call the equality operator).

The = operator will assign what is on the right-hand side to the left-hand side of the equal sign.

The == operator will test to see if what is on the right-hand side is equal to the left-hand side. If they are equal, the == operator returns to use the value of true (which is 1). If they are not equal, it returns the value of false (which is zero).

These two new operators are also on the precedence list, and now we can expand the list to this:
    ( )                                             Highest
    ==
    =
    *, /
    +, -                                           Lowest

Example 2.3.3
Which means, if we did a statement like this:
    int x = 2;
    int y = x == 3;

x would first be assigned two. Then for y, first x would be compared to three. Since they are not equal, we get a value of false (which is zero), and assign that to y. y is now zero.

Example 2.3.4
To complicate things a tad-bit further, say that we did this:
    int x = 0;
    int y = x == 3 == 5;

First x is assigned zero. Then for y, we first compare three against five. Since they are not equal, we get back the value false (which is zero). We then compare the value of zero to the value of x. They are equal so it returns the value of true (which is one) and assign it to y. y now equals one.

Example 2.3.5
For fast initialization of many variables, we can even do this:
    int x = 3;
    int y;
    int z;
    z = y = x;

All variables now equal three.


Section 2.4

Next up in the wonderful world of C++..........
boolean algebra (created by Mr. Boole)

You will now learn how to do more algebra in binary! Remember our great lesson from last time? We'll for the ones who asked why do I have to know this stuff, it is because working with bits of a number is more important than the number itself. I can guarantee that if you can't do boolean algebra, you will not have a fun time finding a job as a C++ programmer. Boolean algebra is a fundamental component of programming - rather it is C++, straight C, Visual Basic, Pascal, etc. This might be a confusing part for non-programmers, so we are going to spend the rest of the lesson nailing down the basics (What's the use of a lesson if you left confused?).

The great geniuses of C++ came up with the bool data type (::ding, ding, ding::: New Data Type!). This is even a brand new type for fellow C programmers who moved to C++ (Remember C++ is just a superset of C, which means it adds on to C. And if you looked at the name "C++", it is C with the increment operator. Pretty cool, huh?).

Now, if you don't know, the bool data type can hold only two values: true and false. If you want numerical value for these constants, constants are values that never change, use this simple rule:
    true  = one
    false = zero

Example 2.4.1
    bool x = true;
    bool y = (false == x);

Since == has higher precedence over =, we do test for equality first.
Since false does not equal x, it evaluates the value false which is set to y.
When we mean "returns", just think of it as another meaning for the word "equals".

Example 2.4.2
    bool x = false;
    bool y = true;
    bool z = (true == y) == true;
 
First we test true against y which evaluates to true.
We than compare true against true which is true.

Example 2.4.3
    bool x = false;
    bool y = false;
    z = (false == false) == true;

false is first compared to false, which returns true.
The returning true than is compared against true, which returns true.
The returning true is now set to z.


Section 2.5

There are four main operations we use in logic:
    NOT          !
    AND         &&
    OR           ||
    XOR         ^

NOT takes the opposite of a boolean value. If a variable is true, the NOT of it is false. Think of it in English: if a value is not true, it is false.

AND takes two variables and determines if both are true. If both are, AND evaluates to true. If either one or both are false, it evaluates to false.

OR takes two variables and determines if any of them are true. If just one or both are, OR returns true. Otherwise, it is false.

XOR won't be discussed in-depth. XOR stands for Exclusive-OR. It only returns true when only one value is true. If both are the same value (either both true or both false, it evaluates to false).

Now we have to add these (yes, once again) to our precedence list:
    ( )                                             Highest
    !
    ==
    =
    &&
    ||
    *, /
    +, -                                           Lowest

Example 2.5.1
    bool x = true;
    bool y = false;
    bool z = x && y;

x and y is ANDed (&&) together. Since y is false, it makes the entire expression false, and z is set to false.

Example 2.5.2
    bool x = false;
    bool y = !true == x && !x;

!x equals true.
ANDed with x which evaluates false
And that evaluated false compared to !true evaluates to true.
y evaluates true.


New terms to remember

Allocate
And
Boolean
Bugs
Constant
Decrement

false

Initialization
Intial value
increment
Not
Or
Precedence
Undefined
Uninitalized

true

Xor


Review problems

01. What is wrong with this code? (find the bug)
          int x;
          int y = 2;
          int z;

          z = y + 1;
          y = z + y;
          z = z + x;

02.  What values do we get for all the variables?
          int a = 3;
          int b = 45;
          int c = 1;
          bool d = c == 1;
          bool e = false == false == 1;
         
03. Why won't this code compile?
          r = 44;

04. What do we get in this?
          bool x = true;
          bool y = false;
          bool z = ((x == y) == y);

05. What do we get in this?
          bool x = false;
          bool y = true;
          bool z = false == true == false == x;

We will be using these variables in the following examples:
         bool p = true;
         bool q = false;
         bool r = true;

06. bool a = !true;

07. bool b = (false == !false) && true;

08. bool c = q && r == false;

09. bool d = (p && q) || r;

11. bool e = (r && r) && q;

12. bool f = p && (q || r);

13. bool g = !q && p;

14. bool h = !(q || p);

15. bool k  = p && !q || r || p && !p

ML>


Other 18 submission(s) by this author

 


Report Bad Submission
Use this form to tell us if this entry should be deleted (i.e contains no code, is a virus, etc.).
This submission should be removed because:

Your Vote

What do you think of this article (in the Beginner category)?
(The article with your highest vote will win this month's coding contest!)
Excellent  Good  Average  Below Average  Poor (See voting log ...)
 

Other User Comments


 There are no comments on this submission.
 

Add Your Feedback
Your feedback will be posted below and an email sent to the author. Please remember that the author was kind enough to share this with you, so any criticisms must be stated politely, or they will be deleted. (For feedback not related to this particular article, please click here instead.)
 

To post feedback, first please login.