C++ if, if...else and Nested if...

else
In this article, you will learn to create decision making statements in a C++
program using different forms of if..else statement.

C++ if Statement
if (testExpression)

// statements

The if statement evaluates the test expression inside parenthesis.

If test expression is evaluated to true, statements inside the body of if is executed.

If test expression is evaluated to false, statements inside the body of if is skipped.

How if statement works?

Flowchart of if Statement

Above figure describes the working of an if statement.

Example 1: C++ if Statement
// Program to print positive number entered by the user
// If user enters negative number, it is skipped

#include <iostream>
using namespace std;

int main()
{
int number;
cout << "Enter an integer: ";
cin >> number;

// checks if the number is positive

if ( number > 0)
{
cout << "You entered a positive integer: " << number << endl;
}

cout << "This statement is always executed.";

return 0;

Output 1

Enter an integer: 5

You entered a positive number: 5

This statement is always executed.

Output 2

Enter a number: -5

This statement is always executed.

C++ if...else
The if else executes the codes inside the body of if statement if the test
expression is true and skips the codes inside the body of else.

If the test expression is false, it executes the codes inside the body of else statement
and skips the codes inside the body of if.

How if...else statement works?

Flowchart of if...else

Example 2: C++ if...else Statement

// Program to check whether an integer is positive or negative
// This program considers 0 as positive number

#include <iostream>
using namespace std;

int main()
{
int number;
cout << "Enter an integer: ";
cin >> number;
 if ( number >= 0)
{
cout << "You entered a positive integer: " << number << endl;
}

else
{
cout << "You entered a negative integer: " << number << endl;
}

cout << "This line is always printed.";

return 0;
}

Output

Enter an integer: -4

You entered a negative integer: -4.

This line is always printed.

C++ Nested if...else

The if...else statement executes two different codes depending upon whether the
test expression is true or false. Sometimes, a choice has to be made from more than
2 possibilities.

The nested if...else statement allows you to check for multiple test expressions
and execute different codes for more than two conditions.
Syntax of Nested if...else
if (testExpression1)

// statements to be executed if testExpression1 is true

else if(testExpression2)

// statements to be executed if testExpression1 is false and

testExpression2 is true

else if (testExpression 3)

// statements to be executed if testExpression1 and testExpression2

is false and testExpression3 is true

else

// statements to be executed if all test expressions are false

}
Example 3: C++ Nested if...else
// Program to check whether an integer is positive, negative or zero

#include <iostream>
using namespace std;

int main()
{
int number;
cout << "Enter an integer: ";
cin >> number;

if ( number > 0)
{
cout << "You entered a positive integer: " << number << endl;
}
else if (number < 0)
{
cout<<"You entered a negative integer: " << number << endl;
}
else
{
cout << "You entered 0." << endl;
}

cout << "This line is always printed.";

return 0;
}

Output

Enter an integer: 0
You entered 0.

This line is always printed.

Conditional/Ternary Operator ?:
A ternary operator operates on 3 operands which can be used instead of
a if...elsestatement.

Consider this code:

if ( a < b ) {

a = b;

else {

a = -b;

You can replace the above code with:

a = (a < b) ? b : -b;

The ternary operator is more readable than a if...else statement for short
conditions.

C++ Functions
In this article, you'll learn everything about functions in C++; what type of functions
are there, how to use them with examples.
In programming, function refers to a segment that groups code to perform a specific
task.

Depending on whether a function is predefined or created by programmer; there are

two types of function:

1. Library Function
2. User-defined Function

Library Function
Library functions are the built-in function in C++ programming.

Programmer can use library function by invoking function directly; they don't need to
write it themselves.

Example 1: Library Function

#include <iostream>
#include <cmath>

using namespace std;

int main()
{
double number, squareRoot;
cout << "Enter a number: ";
cin >> number;

// sqrt() is a library function to calculate square root

squareRoot = sqrt(number);
cout << "Square root of " << number << " = " << squareRoot;
return 0;
}

Output

Enter a number: 26

Square root of 26 = 5.09902

In the example above, sqrt() library function is invoked to calculate the square root
of a number.

Notice code #include <cmath> in the above program. Here, cmath is a header file.
The function definition of sqrt()(body of that function) is present in the cmath header
file.

You can use all functions defined in cmath when you include the content of
file cmath in this program using #include <cmath> .

Every valid C++ program has at least one function, that is, main() function.

User-defined Function
C++ allows programmer to define their own function.

A user-defined function groups code to perform a specific task and that group of
code is given a name(identifier).

When the function is invoked from any part of program, it all executes the codes
defined in the body of function.
How user-defined function works in C Programming?

Consider the figure above.

When a program begins running, the system calls the main() function, that is, the
system starts executing codes from main() function.

When control of the program reaches to function_name() inside main(), it moves

to void function_name() and all codes inside void function_name() is executed.

Then, control of the program moves back to the main function where the code after
the call to the function_name() is executed as shown in figure above.

Example 2: User Defined Function

C++ program to add two integers. Make a function add() to add integers and
display sum in main() function.

#include <iostream>
using namespace std;

// Function prototype (declaration)

int add(int, int);

int main()
{
int num1, num2, sum;
cout<<"Enters two numbers to add: ";
cin >> num1 >> num2;

// Function call
sum = add(num1, num2);
cout << "Sum = " << sum;
return 0;
}

// Function definition
int add(int a, int b)
{
int add;
add = a + b;

// Return statement
return add;
}

Output

Enters two integers: 8

-4

Sum = 4
Function prototype (declaration)
If a user-defined function is defined after main() function, compiler will show error. It
is because compiler is unaware of user-defined function, types of argument passed
to function and return type.

In C++, function prototype is a declaration of function without its body to give

compiler information about user-defined function. Function prototype in the above
example is:

int add(int, int);

You can see that, there is no body of function in prototype. Also, there are only
return type of arguments but no arguments. You can also declare function prototype
as below but it's not necessary to write arguments.

int add(int a, int b);

Note: It is not necessary to define prototype if user-defined function exists

before main()function.

Function Call
To execute the codes of function body, the user-defined function needs to be
invoked(called).

In the above program, add(num1,num2); inside main() function calls the user-defined
function.

The function returns an integer which is stored in variable add.

Function Definition
The function itself is referred as function definition. Function definition in the above
program is:

// Function definition
int add(int a,int b)

int add;

add = a + b;

return add;

When the function is called, control is transferred to the first statement of the function
body.

Then, other statements in function body are executed sequentially.

When all codes inside function definition is executed, control of program moves to
the calling program.

Passing Arguments to Function

In programming, argument (parameter) refers to the data which is passed to a
function (function definition) while calling it.

In the above example, two variables, num1 and num2 are passed to function during
function call. These arguments are known as actual arguments.

The value of num1 and num2 are initialized to variables a and b respectively. These
arguments a and b are called formal arguments.

This is demonstrated in figure below:

Notes on passing arguments

 The numbers of actual arguments and formals argument should be the same.
(Exception: Function Overloading)
 The type of first actual argument should match the type of first formal argument.
Similarly, type of second actual argument should match the type of second formal
argument and so on.
 You may call function a without passing any argument. The number(s) of argument
passed to a function depends on how programmer want to solve the problem.
 You may assign default values to the argument. These arguments are known
as default arguments.
 In the above program, both arguments are of int type. But it's not necessary to have
both arguments of same type.

Return Statement
A function can return a single value to the calling program using return statement.

In the above program, the value of add is returned from user-defined function to the
calling program using statement below:

return add;

The figure below demonstrates the working of return statement.

In the above program, the value of add inside user-defined function is returned to the
calling function. The value is then stored to a variable sum.

Notice that the variable returned, i.e., add is of type int and sum is also of int type.

Also, notice that the return type of a function is defined in function declarator int
add(int a, int b). The int before add(int a, int b) means the function should return a
value of type int.

If no value is returned to the calling function then, void should be used.

C++ Structures
In this article, you'll learn about structures in C++ programming; what is it, how to
define it and use it in your program.
Structure is a collection of variables of different data types under a single name. It is
similar to a class in that, both holds a collecion of data of different data types.

For example: You want to store some information about a person: his/her name,
citizenship number and salary. You can easily create different variables name, citNo,
salary to store these information separately.

However, in the future, you would want to store information about multiple persons.
Now, you'd need to create different variables for each information per person: name1,
citNo1, salary1, name2, citNo2, salary2

You can easily visualize how big and messy the code would look. Also, since no
relation between the variables (information) would exist, it's going to be a daunting
task.

A better approach will be to have a collection of all related information under a single
name Person, and use it for every person. Now, the code looks much cleaner,
readable and efficient as well.

This collection of all related information under a single name Person is a structure.

How to declare a structure in C++ programming?

The struct keyword defines a structure type followed by an identifier (name of the
structure).

Then inside the curly braces, you can declare one or more members (declare
variables inside curly braces) of that structure. For example:

struct Person

char name[50];

int age;

float salary;

};
Here a structure person is defined which has three members: name, age and salary.

When a structure is created, no memory is allocated.

The structure definition is only the blueprint for the creating of variables. You can
imagine it as a datatype. When you define an integer as below:

int foo;

The int specifies that, variable foo can hold integer element only. Similarly, structure
definition only specifies that, what property a structure variable holds when it is
defined.

Note: Remember to end the declaration with a semicolon (;)

How to define a structure variable?

Once you declare a structure person as above. You can define a structure variable
as:

Person bill;

Here, a structure variable bill is defined which is of type structure Person.

When structure variable is defined, only then the required memory is allocated by the
compiler.

Considering you have either 32-bit or 64-bit system, the memory of float is 4 bytes,
memory of int is 4 bytes and memory of char is 1 byte.

Hence, 58 bytes of memory is allocated for structure variable bill.

How to access members of a structure?

The members of structure variable is accessed using a dot (.) operator.

Suppose, you want to access age of structure variable bill and assign it 50 to it. You
can perform this task by using following code below:
bill.age = 50;

Example: C++ Structure

C++ Program to assign data to members of a structure variable and display it.

#include <iostream>
using namespace std;

struct Person
{
char name[50];
int age;
float salary;
};

int main()
{
Person p1;

cout << "Enter Full name: ";

cin.get(p1.name, 50);
cout << "Enter age: ";
cin >> p1.age;
cout << "Enter salary: ";
cin >> p1.salary;

cout << "\nDisplaying Information." << endl;

cout << "Name: " << p1.name << endl;
cout <<"Age: " << p1.age << endl;
cout << "Salary: " << p1.salary;
 return 0;
}

Output

Enter Full name: Magdalena Dankova

Enter age: 27

Enter salary: 1024.4

Displaying Information.

Name: Magdalena Dankova

Age: 27

Salary: 1024.4

Here a structure Person is declared which has three members name, age and salary.

Inside main() function, a structure variable p1 is defined. Then, the user is asked to
enter information and data entered by user is displayed.

C++ Arrays
In this article, you will learn to work with arrays. You will learn to declare, initialize
and, access array elements in C++ programming.
In programming, one of the frequently arising problem is to handle numerous data of
same type.

Consider this situation, you are taking a survey of 100 people and you have to store
their age. To solve this problem in C++, you can create an integer array having 100
elements.

An array is a collection of data that holds fixed number of values of same type. For
example:

int age[100];

Here, the age array can hold maximum of 100 elements of integer type.

The size and type of arrays cannot be changed after its declaration.

How to declare an array in C++?

dataType arrayName[arraySize];

For example,

float mark[5];

Here, we declared an array, mark, of floating-point type and size 5. Meaning, it can
hold 5 floating-point values.

Elements of an Array and How to access them?

You can access elements of an array by using indices.

Suppose you declared an array mark as above. The first element is mark[0], second
element is mark[1] and so on.
Few key notes:
 Arrays have 0 as the first index not 1. In this example, mark[0] is the first element.
 If the size of an array is n, to access the last element, (n-1) index is used. In this
example, mark[4] is the last element.
 Suppose the starting address of mark[0] is 2120d. Then, the next address, a[1], will
be 2124d, address of a[2] will be 2128d and so on. It's because the size of float is 4
bytes.

How to initialize an array in C++ programming?

It's possible to initialize an array during declaration. For example,

int mark[5] = {19, 10, 8, 17, 9};

Another method to initialize array during declaration:

int mark[] = {19, 10, 8, 17, 9};

Here,

mark[0] is equal to 19

mark[1] is equal to 10
mark[2] is equal to 8

mark[3] is equal to 17

mark[4] is equal to 9

How to insert and print array elements?

int mark[5] = {19, 10, 8, 17, 9}

// change 4th element to 9

mark[3] = 9;

// take input from the user and insert in third element

cin >> mark[2];

// take input from the user and insert in (i+1)th element

cin >> mark[i];

// print first element of the array

cout << mark[0];

// print ith element of the array

cout >> mark[i-1];

Example: C++ Array

C++ program to store and calculate the sum of 5 numbers entered by the user
using arrays.
#include <iostream>
using namespace std;

int main()
{
int numbers[5], sum = 0;
cout << "Enter 5 numbers: ";

// Storing 5 number entered by user in an array

// Finding the sum of numbers entered
for (int i = 0; i < 5; ++i)
{
cin >> numbers[i];
sum += numbers[i];
}

cout << "Sum = " << sum << endl;

return 0;
}

Output

Enter 5 numbers: 3

Sum = 18
Things to remember when working with arrays in C++
Suppose you declared an array of 10 elements. Let's say,

int testArray[10];

You can use the array members from testArray[0] to testArray[9].

If you try to access array elements outside of its bound, let's say testArray[14], the
compiler may not show any error. However, this may cause unexpected output
(undefined behavior).

C++ Classes and Objects

In this article, you will learn to work with objects and classes in C++ programming.

C++ is a multi-paradigm programming language. Meaning, it supports different

programming styles.

One of the popular ways to solve a programming problem is by creating objects,

known as object-oriented style of programming.

C++ supports object-oriented (OO) style of programming which allows you to divide
complex problems into smaller sets by creating objects.
Object is simply a collection of data and functions that act on those data.

C++ Class
Before you create an object in C++, you need to define a class.

A class is a blueprint for the object.

We can think of class as a sketch (prototype) of a house. It contains all the details
about the floors, doors, windows etc. Based on these descriptions we build the
house. House is the object.

As, many houses can be made from the same description, we can create many
objects from a class.

How to define a class in C++?

A class is defined in C++ using keyword class followed by the name of class.

The body of class is defined inside the curly brackets and terminated by a semicolon
at the end.

class className

// some data

// some functions

};

Example: Class in C++

class Test
{
 private:
int data1;
float data2;

public:
void function1()
{ data1 = 2; }

float function2()
{
data2 = 3.5;
return data2;
}
};

Here, we defined a class named Test.

This class has two data members: data1 and data2 and two member
functions: function1()and function2().

Keywords: private and public

You may have noticed two keywords: private and public in the above example.

The private keyword makes data and functions private. Private data and functions
can be accessed only from inside the same class.

The public keyword makes data and functions public. Public data and functions can
be accessed out of the class.

Here, data1 and data2 are private members where as function1() and function2()
are public members.

If you try to access private data from outside of the class, compiler throws error. This
feature in OOP is known as data hiding.
C++ Objects
When class is defined, only the specification for the object is defined; no memory or
storage is allocated.

To use the data and access functions defined in the class, you need to create
objects.

Syntax to Define Object in C++

className objectVariableName;

You can create objects of Test class (defined in above example) as follows:

class Test
{
private:
int data1;
float data2;

public:
void function1()
{ data1 = 2; }

float function2()
{
data2 = 3.5;
return data2;
}
};

int main()
{
 Test o1, o2;
}

Here, two objects o1 and o2 of Test class are created.

In the above class Test, data1 and data2 are data members
and function1() and function2() are member functions.

How to access data member and member function in C++?

You can access the data members and member functions by using a . (dot) operator.
For example,

o2.function1();

This will call the function1() function inside the Test class for objects o2.

Similarly, the data member can be accessed as:

o1.data2 = 5.5;

It is important to note that, the private members can be accessed only from inside
the class.

So, you can use o2.function1(); from any function or class in the above example.
However, the code o1.data2 = 5.5; should always be inside the class Test.

Example: Object and Class in C++ Programming

// Program to illustrate the working of objects and class in C++
Programming
#include <iostream>
using namespace std;

class Test
{
private:
int data1;
float data2;

public:

void insertIntegerData(int d)
{
data1 = d;
cout << "Number: " << data1;
}

float insertFloatData()
{
cout << "\nEnter data: ";
cin >> data2;
return data2;
}
};

int main()
{
Test o1, o2;
float secondDataOfObject2;

o1.insertIntegerData(12);
secondDataOfObject2 = o2.insertFloatData();

cout << "You entered " << secondDataOfObject2;

return 0;
}
Output

Number: 12

Enter data: 23.3

You entered 23.3

In this program, two data members data1 and data2 and two member
functions insertIntegerData() and insertFloatData() are defined under Test class.

Two objects o1 and o2 of the same class are declared.

The insertIntegerData() function is called for the o1 object using:

o1.insertIntegerData(12);

This sets the value of data1 for object o1 to 12.

Then, the insertFloatData() function for object o2 is called and the return value from
the function is stored in variable secondDataOfObject2 using:

secondDataOfObject2 = o2.insertFloatData();

In this program, data2 of o1 and data1 of o2 are not used and contains garbage
value.

C++ Inheritance
In this article, you'll learn everything about inheritance in C++. More specifically, what
is inheritance and different ways to implement it with examples.
Inheritance is one of the key features of Object-oriented programming in C++. It
allows user to create a new class (derived class) from an existing class(base class).

The derived class inherits all the features from the base class and can have
additional features of its own.

Why inheritance should be used?

Suppose, in your game, you want three characters - a maths teacher,
a footballer and a businessman.

Since, all of the characters are persons, they can walk and talk. However, they also
have some special skills. A maths teacher can teach maths, a footballer can play
football and a businessman can run a business.

You can individually create three classes who can walk, talk and perform their
special skill as shown in the figure below.
In each of the classes, you would be copying the same code for walk and talk for
each character.

If you want to add a new feature - eat, you need to implement the same code for
each character. This can easily become error prone (when copying) and duplicate
codes.

It'd be a lot easier if we had a Person class with basic features like talk, walk, eat,
sleep, and add special skills to those features as per our characters. This is done
using inheritance.

Using inheritance, now you don't implement the same code for walk and talk for each
class. You just need to inherit them.

So, for Maths teacher (derived class), you inherit all features of a Person (base
class) and add a new feature TeachMaths. Likewise, for a footballer, you inherit all
the features of a Person and add a new feature PlayFootball and so on.

This makes your code cleaner, understandable and extendable.

It is important to remember: When working with inheritance, each derived class

should satisfy the condition whether it "is a" base class or not. In the example
above, Maths teacher is a Person, Footballer is a Person. You cannot have:
Businessman is a Business.

Implementation of Inheritance in C++ Programming

class Person
{

... .. ...

};

class MathsTeacher : public Person

... .. ...

};

class Footballer : public Person

.... .. ...

};

In the above example, class Person is a base class and

classes MathsTeacher and Footballerare the derived from Person.

The derived class appears with the declaration of a class followed by a colon, the
keyword public and the name of base class from which it is derived.

Since, MathsTeacher and Footballer are derived from Person, all data member and
member function of Person can be accessible from them.

Example: Inheritance in C++ Programming

Create game characters using the concept of inheritance.
#include <iostream>
using namespace std;

class Person
{
public:
string profession;
int age;

Person(): profession("unemployed"), age(16) { }

void display()
{
cout << "My profession is: " << profession << endl;
cout << "My age is: " << age << endl;
walk();
talk();
}
void walk() { cout << "I can walk." << endl; }
void talk() { cout << "I can talk." << endl; }
};

// MathsTeacher class is derived from base class Person.

class MathsTeacher : public Person
{
public:
void teachMaths() { cout << "I can teach Maths." << endl; }
};

// Footballer class is derived from base class Person.

class Footballer : public Person
{
public:
void playFootball() { cout << "I can play Football." << endl; }
};

int main()
{
MathsTeacher teacher;
teacher.profession = "Teacher";
teacher.age = 23;
teacher.display();
teacher.teachMaths();

Footballer footballer;
footballer.profession = "Footballer";
footballer.age = 19;
footballer.display();
footballer.playFootball();

return 0;
}

Output

My profession is: Teacher

My age is: 23

I can walk.

I can talk.

I can teach Maths.

My profession is: Footballer

My age is: 19

I can walk.
I can talk.

I can play Football.

In this program, Person is a base class, while MathsTeacher and Footballer are
derived from Person.

Person class has two data members - profession and age. It also has two member
functions - walk() and talk().

Both MathsTeacher and Footballer can access all data members and member
functions of Person.

However, MathsTeacher and Footballer have their own member functions as

well: teachMaths() and playFootball() respectively. These functions are only
accessed by their own class.

In the main() function, a new MathsTeacher object teacher is created.

Since, it has access to Person's data members, profession and age of teacher is set.
This data is displayed using the display() function defined in the Person class. Also,
the teachMaths() function is called, defined in the MathsTeacher class.

Likewise, a new Footballer object footballer is also created. It has access

to Person's data members as well, which is displayed by invoking
the display() function. The playFootball()function only accessible by the footballer
is called then after.

Access specifiers in Inheritance

When creating a derived class from a base class, you can use different access
specifiers to inherit the data members of the base class.

These can be public, protected or private.

In the above example, the base class Person has been inherited public-ly
by MathsTeacherand Footballer.

C++ Pointers
In this article, you'll learn everything about pointers. You'll learn how values are
stored in the computer and how to access them using pointers.
Pointers are powerful features of C++ that differentiates it from other programming
languages like Java and Python.

Pointers are used in C++ program to access the memory and manipulate the
address.

Address in C++
To understand pointers, you should first know how data is stored on the computer.

Each variable you create in your program is assigned a location in the computer's
memory. The value the variable stores is actually stored in the location assigned.

To know where the data is stored, C++ has an & operator. The & (reference)
operator gives you the address occupied by a variable.

If var is a variable then, &var gives the address of that variable.

Example 1: Address in C++

#include <iostream>
using namespace std;

int main()
{
 int var1 = 3;
int var2 = 24;
int var3 = 17;
cout << &var1 << endl;
cout << &var2 << endl;
cout << &var3 << endl;
}

Output

0x7fff5fbff8ac

0x7fff5fbff8a8

0x7fff5fbff8a4

Note: You may not get the same result on your system.

The 0x in the beginning represents the address is in hexadecimal form.

Notice that first address differs from second by 4-bytes and second address differs
from third by 4-bytes.

This is because the size of integer (variable of type int) is 4 bytes in 64-bit system.

Pointers Variables
C++ gives you the power to manipulate the data in the computer's memory directly.
You can assign and de-assign any space in the memory as you wish. This is done
using Pointer variables.

Pointers variables are variables that points to a specific address in the memory
pointed by another variable.
How to declare a pointer?
int *p;

OR,

int* p;

The statement above defines a pointer variable p. It holds the memory address

The asterisk is a dereference operator which means pointer to.

Here, pointer p is a pointer to int, i.e., it is pointing to an integer value in the

memory address.

Reference operator (&) and Deference operator (*)

Reference operator (&) as discussed above gives the address of a variable.

To get the value stored in the memory address, we use the dereference operator (*).

For example: If a number variable is stored in the memory address 0x123, and it
contains a value 5.

The reference (&) operator gives the value 0x123, while the dereference
(*) operator gives the value 5.

Note: The (*) sign used in the declaration of C++ pointer is not the dereference
pointer. It is just a similar notation that creates a pointer.

Example 2: C++ Pointers

C++ Program to demonstrate the working of pointer.

#include <iostream>
using namespace std;
int main() {
int *pc, c;
 c = 5;
cout << "Address of c (&c): " << &c << endl;
cout << "Value of c (c): " << c << endl << endl;

pc = &c; // Pointer pc holds the memory address of variable c

cout << "Address that pointer pc holds (pc): "<< pc << endl;
cout << "Content of the address pointer pc holds (*pc): " << *pc <<
endl << endl;

c = 11; // The content inside memory address &c is changed from

5 to 11.
cout << "Address pointer pc holds (pc): " << pc << endl;
cout << "Content of the address pointer pc holds (*pc): " << *pc <<
endl << endl;

*pc = 2;
cout << "Address of c (&c): " << &c << endl;
cout << "Value of c (c): " << c << endl << endl;

return 0;
}

Output

Address of c (&c): 0x7fff5fbff80c

Value of c (c): 5

Address that pointer pc holds (pc): 0x7fff5fbff80c

Content of the address pointer pc holds (*pc): 5

Address pointer pc holds (pc): 0x7fff5fbff80c

Content of the address pointer pc holds (*pc): 11

Address of c (&c): 0x7fff5fbff80c

Value of c (c): 2

Explanation of program

 When c = 5; the value 5 is stored in the address of variable c - 0x7fff5fbff8c.

 When pc = &c; the pointer pc holds the address of c - 0x7fff5fbff8c, and the
expression (dereference operator) *pc outputs the value stored in that address, 5.
 When c = 11; since the address pointer pc holds is the same as c - 0x7fff5fbff8c,
change in the value of c is also reflected when the expression *pc is executed, which
now outputs 11.
 When *pc = 2; it changes the content of the address stored by pc - 0x7fff5fbff8c.
This is changed from 11 to 2. So, when we print the value of c, the value is 2 as well.

Common mistakes when working with pointers

Suppose, you want pointer pc to point to the address of c. Then,
int c, *pc;

pc=c; /* Wrong! pc is address whereas, c is not an address. */

*pc=&c; /* Wrong! *pc is the value pointed by address whereas, %amp;c

is an address. */

pc=&c; /* Correct! pc is an address and, %amp;pc is also an address. */

*pc=c; /* Correct! *pc is the value pointed by address and, c is also a

value. */

In both cases, pointer pc is not pointing to the address of c.