What are statements?

Statements are instructions given to the computer to perform any kind of action. They form the smallest executable unit within a C++ program. Statements are terminated with a semicolon ( ; ).

It can be a simple statement such as this.👇

int profit = SellingPrice - CostPrice ;

or, it can be a sequence of simple statements enclosed by a pair of braces {}. For instance,

{
   statement1;
   statement2;
   .
   .
   .
}

Statement Flow Control

In a program, statements may be executed sequentially, selectively or iteratively. Let us see what these mean.

1. Sequence

The sequence construct means the statements are being executed sequentially i.e, one after the another. This represents the default flow of the statement. Every C++ program begins with the first statement of main()**.* When the last statement of main()* is executed, the program is done.

1. Selection

The selection construct means the execution of statement(s) depending upon a condition-test. If the condition evaluates to true, a course of action (a set of statements) is followed otherwise another course of action (set of statements) is followed. This construct is also called the decision construct.

1. Iteration

The iteration construct means the repetition of a set-of-statements depending upon a condition-test. Till the time a condition is true (or false depending upon the loop), a set-of-statements are repeated again and again. As soon as the condition becomes false(or true), the repetition stops. Such iteration construct is called a looping construct. The condition on which the execution or exit of the loop depends is called the exit condition or test-codition.

As you have seen selection and iteration constructs depend upon a conditional expression that determines what course-of-action is to be taken. A conditional expression evaluates to either true or false. In C++, any nonzero value is a true value including negative numbers. A 0 (zero) is treated as false.

In this article, we will look at selection statements and in the upcoming article we will learn about iterative statements.

Selection Statements

C++ provides two types of selection statements: if and switch

The if Statement of C++

An if statement tests a particular condition; if the condition evaluates to true, a course-of-action is followed i.e, a statement or set of statements is executed. Otherwise, the course of action is ignored. The general syntax of an if statement is as follows:

if (expression)
statement;

where a statement may consist of a single statement, a compound statement or nothing. The expression must be enclosed within parentheses. If the expression evaluates to true, the statement is executed, otherwise ignored.

Consider this example:

if (x)
{
   cout<<"x is non-zero";
}
if (!x)
cout<<"!x is zero this time";

If the value of x is zero, The above code will display :

!x is zero this time

And for non-zero values of x, it will display :

x is non -zero

The expression can contain a variety of test-conditions, such as:

if(grade == 'A' || grade == 'a')     
   cout<<"Excellent";

if(a>b)
  cout<<"A has more than B has";

if ((x >= 2) && (x<= 10))
   {                     //The if body contains a compound statement
      cout<<"x is greater than 2 and less than 10";
       x = x+20;
    }

Now, what if there is another course of action to be followed if the expression evaluates to false? There is another form of if that allows for this kind of either-or condition by providing the else clause. The syntax of an if-else statement is:

if(expression)
   statement 1;
else
   statement 2;

If the expression evaluates to true, statement-1 is executed, otherwise, statement-2 is executed. Statement-1 and statement-2 can be a single statement, compound statement or null statement.

if (100 > x)
   cout<<" 100 is greater than x";// if 100>x evaluate to true
else
   cout<<" 100 is smaller than x"; //if 100>x evaluate to false

Nested ifs:

A nested if is an if that has another if in its if's body or in its else's body. It can have one of three forms:

CLICK HERE for an example program which illustrates the use of nested ifs.

The Dangling-Else Problem

The nested if-else statement introduces a source of potential ambiguity referred to as a dangling-else problem. This problem arises when in a nested if statement, the number of ifs is more than the number of else clauses. The question then arises, with which if does the additional else clause property matchup? For instance,

if(ch>= 'A')
  if(ch <= 'Z')
       ++upcase;
else
  ++others;

The indentation in the above code fragment indicates that we want the else to be with the outer if. However, C++ matches an else with the preceding unmatched if. In this case, the actual evaluation happens something like this:

if(ch>= 'A')
  if(ch<= 'Z')  //---the else clause matches up with this if statement
      ++upcase;
  else
      ++others;

That is, if the inner expression is false i.e, zero then the else clause gets executed.

What if you want to override the default dangling-else matching? i.e, consider:

if(exp1)
   if(exp2)
      statement1;
else
      statement2;

you want the else to go with the other if. (By default, it will go with the inner if).

One method of overriding the default dangling-else matching is to place the last occurring unmatched if in a compound statement, as shown below:

if(exp1)
{
    if(exp2)
       statement1;
}
else               //Now wlse matches up with the outer if.
       statement2;

CLICK HERE to view the program illustrating the use of dangling-else matching.

The if-else-if Ladder:

It takes the following general form:

if(expression 1) 
   statement 1;
else if(expression 2) 
   statement 2;
else if(expression 3)
   statement 3;
          .
          .
else
   statement 4;

The expressions are evaluated from the top downward. As soon as an expression evaluates to true, the statement associated with it is executed and the rest of the ladder is bypassed. If none of the expressions is true, the final else gets executed. If the final else is missing, no action takes place if all other conditions are false.

CLICK HERE for a program which illustrates the if-else-if ladder.

The Switch Statement

C++ provides a multiple-branch selection statement known as switch. This selection statement successively tests the value of an expression against a list of integers or character constants. When a match is found, the statements associated with that constant are executed.

The syntax of switch is as follows:

switch (expression)
{
  case constant1 :   statement sequence 1;
                     break;
  case constant2 :   statement sequence 2;
                     break;
  case constant3 :   statement sequence 3;
                     break;
  .
  .
  .
  case constant n-1 :statement sequence m-1;
                     break;
  default        : statement sequence n;

The expression is evaluated and its values are matched against the values of the constants specified in the case statements. When a match is found, the statement sequence associated with that case is executed until the break statement or the end of the switch statement is reached. If the case statement does not include a break statement, then the control continues right on the next case statement(s) until either a break is encountered or the end of switch is reached. This situation is called a fall-through.

The default statement gets executed when no match is found. The default statement is optional and, if it is missing, no action takes place if all matches fail. The break statement is one of C++ jump statements. When a break statement is encountered in a switch statement program execution jumps to the line of code following the switch statement i.e, outside the body of switch statement.

CLICK HERE to view the program which illustrates the switch statement.

Now, you may be confused by seeing the switch statement. It does a similar job to if-else. So, let us see the key differences between the two.

The Switch Vs If-Else

1. Switch can only test for equality whereas if can evaluate a relational or logical expression i.e, multiple conditions.

2. The switch statement selects its branches by testing the value of same variable against a set of constants whereas, the if-else construction lets you use a series of expressions that may involve unrelated variables and complex expressions.

3. The if-else statement can handle floating-point tests also apart from handling integer and character tests whereas a switch cannot handle floating-point tests. The case label of switch must be an integer ( which includes char also)

4. The switch statement is a more efficient choice in terms of code used in a situation that supports the nature of switch operation (testing a value against a set of constants)

The Nested-Switch:

Like if statements, a switch statement can also be nested. There can be a switch as part of the statement sequence of another switch. For example:

switch(a)
{
   case 1 : switch (b)
             {
                 case 0 : cout<<"inside nested-switch case 0";
                          break;
                 case 1 : x= (a+b)/2;
                          break;
              }
             break;
   case 2   :
  .
  .
  .
}

Some Important Things About Switch Statement

1. A switch statement can only work for equality comparisons.

2. No two case labels in the same switch can have identical values. But, in the case of nested switch statements the case constants of the inner and outer switch can contain common values.

3. If character constants are used in the switch statement, they are automatically converted to their integers. (i.e, their equivalent ASCII codes)

4. Remember to always put the break statement after the last case statement in a switch.

Thats it folks. If you have followed along until the end, you must have a basic understanding of C++ selection statements. So, stop not! Pickup a few questions on these and start coding🧑‍💻.

Please feel free to start a discussion in the comments section, react to this article and stay tuned for more C++.🤠

"Don't let what you cannot do interfere with what you can do." - John R. Wooden

In this article, I will be talking about the increment/decrement operator in C++. This is a type of operator that may get a little bit confusing for beginners in C++, especially postfix/prefix distinction which we will soon see. Let's hop in and make this easy for you.

C++ includes two useful operators not generally found in other programming languages (except C). These are the :

• Increment operator ++

• Decrement operator --

The C++ name itself is influenced by the increment operator ++. In simple words, these operators add/subtract 1 from their operands. i.e

a = a + 1;  is same as ++a; or a++;

a = a - 1;  is same as --a; or a--;

However, both come in two varieties: they may either precede or follow the operand.

• The Prefix version comes before the operand (as in ++a or --a)

• The Postfix version comes after the operand (as in a++ or a--)

The two versions have the same effect on the operand, but they differ when they take place in an expression.

Working with the Prefix version

When an increment or decrement operator precedes its operand, C++ performs the increment or decrement operation before using the value of the operand. It follows the change-then-use rule i.e., they first change the value of their operand, then use the new value in evaluating the expression.

For example, consider below assuming the initial values of sum and count are 0 and 10 respectively.

sum = sum + (++count);

The expression below will also similarly take place, assuming the initial values of P and N are 4 and 8 respectively.

P = P * --N;

Working with the Postfix version

When an increment or decrement operator follows its operand, C++ first uses the value of the operand in evaluating the expression before incrementing or decrementing the operand's value. It follows the use-then-change rule i.e., they first use the value of their operand in evaluating the expression and then change the operand's value.

For example, the expression below will take place in the following fashion assuming the initial values of sum and count are 0 and 10 respectively.

sum = sum + count++ ;

The expression below will take place similarly, assuming the initial values of P and N are 4 and 8 respectively.

P = P * N--

Please note that the overall effect on the operand's value, in both cases of prefix and postfix operators, is the same (the final value of ++count & count++ and --N & N-- are the same). However, they differ in when they take place in the evaluation of an expression.

Now that we have understood the basics, we will see some examples.

Example 1

Predict the output of the following code snippet:

int n = 7;
cout<< "n++ =" << n++<<endl; //first-use-then-increment rule.
cout<<"n= " << n <<"\n";    //incremented value is shown here

The output of the above code will be:

n++ = 7

n=8

Example 2

Predict the output of the following code snippet:

int n = 7;
cout<< "++n =" << ++n <<endl;
cout<<"n =" << n <<"\n"

The output of the above code will be:

++n =8

n = 8

Hope this article has cleared up the confusion on prefix and postfix increment/decrement operators.

Follow this space for more articles on C++

In this article, we will be focusing on version control systems, their need and types and finally, we will learn how Git, which is one of the many version control systems available and used by many works. This is going to be a long one, so bear with me😀

What is version control?

Version control is a system that records changes ta a file or set of files over time so that you can recall specific versions later. You may think this is only for software source code files, but in reality, you can do this with nearly any type of file on a computer.

If you are a developer, you would want to keep track of the changes made to your source code files, so a Version Control System (VCS) would be a very wise thing to use. It allows you to revert selected files to a previous state, revert the entire project to a previous state, compare changes over time, see who last modified something that might be causing an issue and many more. Sounds magical right?🪄 well it's not! it's just technology! 😎

Types of Version Control Systems

• Local version control systems:

  Many people's version-control method of choice is to copy files into another directory. A common approach but very error-prone. It is easy to forget which directory you're in and accidentally write to the wrong file or copy over files you didn't mean to. To deal with this programmers developed local VCS that had a simple database that kept all changes to the file under revision.

• Centralized version control systems:

  The next major issue people encountered is that they needed to collaborate with developers on other systems. To deal with this CVCS was developed having a single server that contains all the versioned files and the history of what everyone on the project is doing. However, this setup has some serious downsides. What if the centralized server faces failure or what if the hard disk on the central database becomes corrupted? You lose absolutely everything.

  

• Distributed version control systems:

  This is where DVCS steps in! In a DCVS, users don't just check out the latest snapshot of the files; rather, they fully mirror the repository (folder), including its full history. Thus, if the server dies, and these systems were collaborating via that server, any of the user's repositories can be copied back to the server to restore it.

What is Git?

Try to absorb this section effectively, as it will probably be much easier to grasp the further concepts.

Git is a distributed version control system developed by Linus Torvalds. It is an open-source project initiated in 2005.

We will now look at some feature which makes Git a one of its kind technology!

1. Snapshots, Not differences

   The major difference between Git and other VCS(CVS, Subversion, Perforce etc) is the way Git thinks about data. These other systems think of the information they store as a set of files and the changes made to each file over time.

Git doesn't think of data this way. Instead, it thinks of data more like a series of snapshots of a miniature filesystem. With Git, every time you commit or save the state of your project, it basically takes a picture of what all your files looked like at that moment and stores a reference to that snapshot. More like a stream of snapshot

s

1. Nearly every operation is local

   Most operations in Git only need local files and resources to operate. Since the whole codebase and history of your project is available on your local machine, the Git operations are executed in no time.

   This also means your work is not hindered if you are offline. If you are travelling somewhere and you wish to get some work done, you can do so without worries as all the magic happens locally. How cool is that!

   

2. Git has Integrity

   Everything in Git is checksummed before it is stored and is then referred to by that checksum. This means it's impossible to change the content of any file/directory without git knowing it. You can't lose information in transit or get file corruption without Git being able to detect it. It uses the SHA-1 hash checksumming method. It's a 40-character string composed of hexadecimal characters which looks something like this:

24b9da6552252987aa493b52f8696cd6d3b00373

In fact, Git stores everything in its database not by file name but by the value of its content.

1. The three states

   

   Git has three main states that your file can reside in Modified, Staged and Committed.

   • Modified means that you have made some changes in the file, but Git has not yet tracked those changes

   • Staged means that you have tracked the changes in the modified file using Git and are ready for a commit snapshot

   • Committed means that the data is safely stored in your local database.

The basic Git workflow goes something like this :

1.  You modify files in your working tree.

2.  You selectively stage those changes you want to be part of your next commit, which adds only those changes to the staging area.

3.  You do a commit, which takes the file as they are in the staging area and stores that snapshot permanently in your Git directory.

To summarize, If a particular version of a file is in the Git directory, it's committed. If it has been modified and added to the staging area, it is staged. And if it was changed since it was checked out but has not been staged, it is modified.

If you have come this far, I really appreciate your effort. So, leave with a smile on your face:

References:

1. Pro Git by Scott Chacon and Ben Straub, Second edition

Stay tuned for more articles on this topic.😎

Begin with the end in mind -Dr. Stephen R. Covey

Hi. I welcome you to this series where I will be documenting my journey learning one of my favourite programming languages i.e C++. Although I had studied C++ before in my classes 11 and 12 as a computer science student, I was not exposed to the world of creating projects, community contributions or any of it. We were just thought from the textbook and the lab sessions were done in TurboC++ 🤧.

As you can see the teaching pedagogy was outdated. It was only when I entered college that I realized tools such as VScode, Git and GitHub etc which make developer's work easy and efficient.

So, that is why this series will try to introduce beginners to efficient coding tools and the latest practices all the while learning the programming language C++.

I will be writing about basic to advanced C++ all the while building some cool projects to get hands-on learning. Topics including variables, data types, flow of control, pointers, and data structures will be written. I will be executing programs on each concept and everything related to this series will be shared in this GitHub Repo. Feel free to look into the repository and any contributions are welcome!

For my journey I will primarily use these textbooks and online resources :

• Computer Science with C++ by Sumita Arora, 9th edition (although outdated, its very beginner friendly)

• Object Oriented Programming with C++ by Reema Thareja, Revised first edition

• Freecodecamp's Youtube Tutorials.

That is it for this article. I have kept a goal of 3 articles per week😎. I am so excited to share this journey with you and looking forward for your support. Let's Begin.!🗿