Basic If Statement Syntax
The structure of an if statement is as follows:
-------------------------------------------------
if ( TRUE )
-------------------------------------------------
Execute the next statement

------------------------------------------------- if ( TRUE ) {
-------------------------------------------------
Execute all statements inside the braces
-------------------------------------------------
}

Syntax:
The syntax of an if...else statement in C++ is:
-------------------------------------------------
if(boolean_expression)
-------------------------------------------------
{
-------------------------------------------------
// statement(s) will execute if the boolean expression is true
-------------------------------------------------
}
-------------------------------------------------
else
-------------------------------------------------
{
-------------------------------------------------
// statement(s) will execute if the boolean expression is false
-------------------------------------------------
}
-------------------------------------------------

-------------------------------------------------
#include <iostream>
-------------------------------------------------
using namespace std;
-------------------------------------------------

------------------------------------------------- int main ()
-------------------------------------------------
{
-------------------------------------------------
// local variable declaration:
-------------------------------------------------
int a = 100;
-------------------------------------------------

------------------------------------------------- // check the boolean condition
-------------------------------------------------
if( a < 20 )
-------------------------------------------------
{
-------------------------------------------------
// if condition is true then print the following
-------------------------------------------------
cout << "a is less than 20;" << endl;
-------------------------------------------------
}
-------------------------------------------------
else
-------------------------------------------------
{
-------------------------------------------------
// if condition is false then print the following
-------------------------------------------------
cout << "a is not less than 20;" << endl;
-------------------------------------------------
}
-------------------------------------------------
cout << "value of a is : " << a << endl;
-------------------------------------------------

------------------------------------------------- return 0;
-------------------------------------------------
}

A while loop statement repeatedly executes a target statement as long as a given condition is true.
Syntax:
The syntax of a while loop in C++ is:
-------------------------------------------------
while(condition)
-------------------------------------------------
{
-------------------------------------------------
statement(s);
-------------------------------------------------
}
Here, statement(s) may be a single statement or a block of statements. The condition may be any expression, and true is any non-zero value. The loop iterates while the condition is true.
When the condition becomes false, program control passes to the line immediately following the loop.
-------------------------------------------------
#include <iostream>
-------------------------------------------------
using namespace std;
-------------------------------------------------

------------------------------------------------- int main ()
-------------------------------------------------
{
-------------------------------------------------
// Local variable declaration:
-------------------------------------------------
int a = 10;
-------------------------------------------------

------------------------------------------------- // while loop execution
-------------------------------------------------
while( a < 20 )
-------------------------------------------------
{
-------------------------------------------------
cout << "value of a: " << a << endl;
-------------------------------------------------
a++;
-------------------------------------------------
}
-------------------------------------------------

------------------------------------------------- return 0;
-------------------------------------------------
}
Unlike for and while loops, which test the loop condition at the top of the loop, thedo...while loop checks its condition at the bottom of the loop.
A do...while loop is similar to a while loop, except that a do...while loop is guaranteed to execute at least one time.
Syntax:
The syntax of a do...while loop in C++ is:
-------------------------------------------------
do
-------------------------------------------------
{
-------------------------------------------------
statement(s);
-------------------------------------------------
}while( condition );
Notice that the conditional expression appears at the end of the loop, so the statement(s) in the loop execute once before the condition is tested.
If the condition is true, the flow of control jumps back up to do, and the statement(s) in the loop execute again. This process repeats until the given condition becomes false.
-------------------------------------------------
#include <iostream>
-------------------------------------------------
using namespace std;
-------------------------------------------------

------------------------------------------------- int main ()
-------------------------------------------------
{
-------------------------------------------------
// Local variable declaration:
-------------------------------------------------
int a = 10;
-------------------------------------------------

------------------------------------------------- // do loop execution
-------------------------------------------------
do
-------------------------------------------------
{
-------------------------------------------------
cout << "value of a: " << a << endl;
-------------------------------------------------
a = a + 1;
-------------------------------------------------
}while( a < 20 );
-------------------------------------------------

------------------------------------------------- return 0;
-------------------------------------------------
}
A for loop is a repetition control structure that allows you to efficiently write a loop that needs to execute a specific number of times.
Syntax:
The syntax of a for loop in C++ is:
-------------------------------------------------
for ( init; condition; increment )
-------------------------------------------------
{
-------------------------------------------------
statement(s);
-------------------------------------------------
}
Here is the flow of control in a for loop: * The init step is executed first, and only once. This step allows you to declare and initialize any loop control variables. You are not required to put a statement here, as long as a semicolon appears. * Next, the condition is evaluated. If it is true, the body of the loop is executed. If it is false, the body of the loop does not execute and flow of control jumps to the next statement just after the for loop. * After the body of the for loop executes, the flow of control jumps back up to theincrement statement. This statement allows you to update any loop control variables. This statement can be left blank, as long as a semicolon appears after the condition. * The condition is now evaluated again. If it is true, the loop executes and the process repeats itself (body of loop, then increment step, and then again condition). After the condition becomes false, the for loop terminates. * -------------------------------------------------
#include <iostream> * ------------------------------------------------- using namespace std; * ------------------------------------------------- * ------------------------------------------------- int main () * -------------------------------------------------
{
* ------------------------------------------------- // for loop execution * ------------------------------------------------- for( int a = 10; a < 20; a = a + 1 ) * ------------------------------------------------- { * ------------------------------------------------- cout << "value of a: " << a << endl; * ------------------------------------------------- } * ------------------------------------------------- * ------------------------------------------------- return 0; * -------------------------------------------------
}

A switch statement allows a variable to be tested for equality against a list of values. Each value is called a case, and the variable being switched on is checked for each case.
Syntax:
The syntax for a switch statement in C++ is as follows:
-------------------------------------------------
switch(expression){
-------------------------------------------------
case constant-expression :
-------------------------------------------------
statement(s);
-------------------------------------------------
break; //optional
-------------------------------------------------
case constant-expression :
-------------------------------------------------
statement(s);
-------------------------------------------------
break; //optional
-------------------------------------------------

------------------------------------------------- // you can have any number of case statements.
-------------------------------------------------
default : //Optional
-------------------------------------------------
statement(s);
-------------------------------------------------
}
The following rules apply to a switch statement: * The expression used in a switch statement must have an integral or enumerated type, or be of a class type in which the class has a single conversion function to an integral or enumerated type. * You can have any number of case statements within a switch. Each case is followed by the value to be compared to and a colon. * The constant-expression for a case must be the same data type as the variable in the switch, and it must be a constant or a literal. * When the variable being switched on is equal to a case, the statements following that case will execute until a break statement is reached. * When a break statement is reached, the switch terminates, and the flow of control jumps to the next line following the switch statement. * Not every case needs to contain a break. If no break appears, the flow of control will fall through to subsequent cases until a break is reached. * A switch statement can have an optional default case, which must appear at the end of the switch. The default case can be used for performing a task when none of the cases is true. No break is needed in the default case. * -------------------------------------------------
#include <iostream> * ------------------------------------------------- using namespace std; * ------------------------------------------------- * ------------------------------------------------- int main () * -------------------------------------------------
{
* ------------------------------------------------- // local variable declaration: * ------------------------------------------------- char grade = 'D'; * -------------------------------------------------

* ------------------------------------------------- switch(grade) * ------------------------------------------------- { * ------------------------------------------------- case 'A' : * ------------------------------------------------- cout << "Excellent!" << endl; * ------------------------------------------------- break; * ------------------------------------------------- case 'B' : * ------------------------------------------------- case 'C' : * ------------------------------------------------- cout << "Well done" << endl; * ------------------------------------------------- break; * ------------------------------------------------- case 'D' : * ------------------------------------------------- cout << "You passed" << endl; * ------------------------------------------------- break; * ------------------------------------------------- case 'F' : * ------------------------------------------------- cout << "Better try again" << endl; * ------------------------------------------------- break; * ------------------------------------------------- default : * ------------------------------------------------- cout << "Invalid grade" << endl; * ------------------------------------------------- } * ------------------------------------------------- cout << "Your grade is " << grade << endl; * ------------------------------------------------- * ------------------------------------------------- return 0; * -------------------------------------------------
}

A function is a group of statements that together perform a task. Every C++ program has at least one function, which is main(), and all the most trivial programs can define additional functions.
A C++ function definition consists of a function header and a function body. Here are all the parts of a function: * Return Type: A function may return a value. The return_type is the data type of the value the function returns. Some functions perform the desired operations without returning a value. In this case, the return_type is the keyword void. * Function Name: This is the actual name of the function. The function name and the parameter list together constitute the function signature. * Parameters: A parameter is like a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters. * Function Body: The function body contains a collection of statements that define what the function does.
Example:
Following is the source code for a function called max(). This function takes two parameters num1 and num2 and returns the maximum between the two:
-------------------------------------------------
// function returning the max between two numbers
-------------------------------------------------

------------------------------------------------- int max(int num1, int num2)
-------------------------------------------------
{
-------------------------------------------------
// local variable declaration
-------------------------------------------------
int result;
-------------------------------------------------

------------------------------------------------- if (num1 > num2)
-------------------------------------------------
result = num1;
-------------------------------------------------
else
-------------------------------------------------
result = num2;
-------------------------------------------------

------------------------------------------------- return result;
-------------------------------------------------
}

Void Functions
A void function has a heading that names the function followed by a pair of parentheses. The function identifier/name is preceded by the word void. The parameter list with the corresponding data type is within the parentheses. The body of the function is between the pair of braces.
Here is the syntax template of a void function prototype:
-------------------------------------------------
void functionName(DataTypeOfParameterList);
Here is the syntax template of a void function definition:
-------------------------------------------------
void functionName(DataTypeWithParameterList)
-------------------------------------------------
{
-------------------------------------------------
Statement
-------------------------------------------------
.
-------------------------------------------------
.
-------------------------------------------------
.
-------------------------------------------------
}
Example
-------------------------------------------------
// Program Stars prints NUM_STARS on the screen.
-------------------------------------------------

-------------------------------------------------
#include <iostream>
-------------------------------------------------
using namespace std;
-------------------------------------------------

------------------------------------------------- const int NUM_STARS = 10;
-------------------------------------------------

------------------------------------------------- void PrintStars(); //Function prototype, no parameter
-------------------------------------------------
// Prints NUM_STARS stars on the screen.
-------------------------------------------------

------------------------------------------------- int main ()
-------------------------------------------------
{
-------------------------------------------------
cout << "The next line contains " << NUM_STARS
-------------------------------------------------
<< " stars. " << endl;
-------------------------------------------------
PrintStars(); //Function call
-------------------------------------------------
PrintStars(); //Function call
-------------------------------------------------
return 0;
-------------------------------------------------
}
-------------------------------------------------

-------------------------------------------------
//********************************************************
-------------------------------------------------
//Function definition, no parameter
-------------------------------------------------
//********************************************************
-------------------------------------------------

------------------------------------------------- void PrintStars ()
-------------------------------------------------
// Post: NUM_STARS asterisks are sent to cout.
-------------------------------------------------

-------------------------------------------------
{
------------------------------------------------- cout << "**********" << endl;
-------------------------------------------------
return;
-------------------------------------------------
}
C++ inline function is powerful concept that is commonly used with classes. If a function is inline, the compiler places a copy of the code of that function at each point where the function is called at compile time.
Any change to an inline function could require all clients of the function to be recompiled because compiler would need to replace all the code once again otherwise it will continue with old functionality.
To inline a function, place the keyword inline before the function name and define the function before any calls are made to the function. The compiler can ignore the inline qualifier in case defined function is more than a line.
A function definition in a class definition is an inline function definition, even without the use of the inline specifier.
Example Inline Function
-------------------------------------------------
#include <iostream>
-------------------------------------------------

------------------------------------------------- using namespace std;
-------------------------------------------------

------------------------------------------------- inline void hello()
-------------------------------------------------
{
-------------------------------------------------
cout<<"hello";
-------------------------------------------------
}
-------------------------------------------------
int main()
-------------------------------------------------
{
-------------------------------------------------
hello(); //Call it like a normal function...
-------------------------------------------------
cin.get();
-------------------------------------------------
}
However,