The Engineering Projects

C++ Variables & Constants

In the previous topic, we have discussed data types in C++ in detail. Today we will discuss variables and constants in C++.

A named memory location or memory cell is called a variable. The program's input data and its results are stored in variables during execution. During the execution of the program, the value of a variable can be changed but its name can not be changed.

Variables are created in random access memory. As we know that RAM is a temporary memory so data stored in it is also temporary. It can only be used during execution. When the program ends, the data stored in the variable is automatically removed.

In C++, all the variables are declared first:

• Name of variable: an identifier that represents a memory location.
• Address of variable: memory location of the variable.
• Contents of variable: the value stored in a memory location.

Variable Declaration:

• Variable declaration is the process of specifying the name and the type of variable.
• Before a variable is used, it can be declared anywhere in the program before its execution.
• Information is provided to the compiler about the variable by variable declaration.
• The compiler determines the memory required for each variable.
• After the declaration, the required memory of bytes is allocated to variables.
• Once the variable is declared then its name and data type can not be changed but its value can be changed during execution.
• For example, an integer required 2 bytes of memory but a character required one byte of memory. During execution int and char data types can not be changed but integer value can be changed from 5 to 9 and character can be changed from ‘f’ to ‘g’.

SYNTAX of declaring a variable in C++

• data-type: type of data that is stored in a variable.
• variable-name: tell us about the memory location of the variable.

For example:

int num1=25, num2=1000;

We can also write it like this:

int num1,num2; num1=25; num2=1000;

Types of Variables 

Types of Variables can be categorized in two ways

• Types of variables regarding data types
• Types of variables regarding the scope

Types of variables regarding data type:

Based on the data type of variable, there are the following categories of variables in C++

• int: holds an integer value i.e. 1, 2, 3, 50 etc.
• char: holds character values like ‘c’, ‘F’, ‘B’, ‘p’, ‘g’, ‘q’ etc.
• bool: holds boolean value true or false(0 or 1).
• double: holds double-precision floating-point value.
• float: holds single-precision floating-point value.

Example

Different types of variables can be declared as follow:

• int marks;
• float average;
• char grade;
• double salary;

Variables having the same data type can be declared in a single line. Each variable in line should be separated by a comma as follows:

int  a, b, c;

Types of variables regarding scope

When we discussed the Hello Program, we have seen the curly braces in the program like this:

int main { //Some code }

When variables are declared in curly braces then their scope is limited within these braces. The variable declared in main() function can not be used outside the main() function.

There are two types of variables based on their scope.

1. Global variable
2. Local variable

Global Variable

Global variables are always declared outside of any function.

• Their scope is in the complete program so can be accessed anywhere in the program.
• Can be accessed in the main() function, in the user-defined function and anywhere in the program.

Global variable example

Let us have a global variable myvar and it is declared outside of main. We can access the variable twice in the main() function easily.

#include <iostream> using namespace std; // This is a global variable char myvar = 'G'; int main() { cout <<"Value of myvar: "<< myvar<<endl; myVar='m'; cout <<"Value of myvar: "<< myvar; return 0; }

Output:

• Value of myvar: G
• Value of myvar: m

Local variable

• They are declared inside the curly braces of any loop or control statement, main function, user-defined function and their scope is limited only to the curly braces so they can be used only within the curly braces.

Local variable example

#include <iostream> using namespace std;   char myFuncn() { // This is a local variable char myVar = 'X’; } int main() { cout <<"Value of myVar: "<< myVar<<endl; myVar='H’; cout <<"Value of myVar: "<< myVar; return 0; }

Output:

• As we are trying to access the variable outside its scope so a compile-time error will occur.
• Local and global variables may or may not have the same name.
• We can see an example having the same name for local and global variables.

#include <iostream> using namespace std; // This is a global variable char myVar = 'X'; char myFuncn() { // This is a local variable char myVar = 'Y’; return myVar; } int main() { cout <<"Funcn call: "<< myFuncn()<<endl; cout <<"Value of myVar: "<< myVar<<endl; myVar='A'; cout <<"Funcn call: "<< myFuncn()<<endl; cout <<"Value of myVar: "<< myVar<<endl; return 0; }

Output:

Funcn call: X

Value of myVar: Y

Funcn call: X

Value of myVar: A

As the scope of the local variable is limited so the changed value of the variable is only responded for the global variable and the value of the local variable remained the same ‘ X’.

 

RULES FOR DECLARING VARIABLES:

There are some rules in C++ for naming variables

• Variable can be a letter, number and underscore(-).
• Variable’s first letter should be a letter or underscore. The variables 6second, $6payment and 5kg are invalid.
• In the variable name, blank spaces can not be added. ‘ my var’ is an invalid variable.
• Both upper and lower cases can be used. User-defined variables are written in lower and constants are written in upper case conventionally.
•  special symbols can not be used in variables as a name.
• Reserved words can not be used as a variable name. e.g int, for, while etc can not be used as a variable name.
• The no of characters in the variable should not be more than 31.
• A variable can not be declared for more data types. It should be declared for only one data type.

Variable declaration vs variable definition:

•  The variable declaration tells us about the part where the variable was first declared before its use.
• While variable definition tells us about that part where variable assigned memory location and value
• Variable definition and declaration did at a time mostly.

#include <iostream> using namespace std; int main() { // declaration and definition of variable 'b123' char b123 = 'a'; float b; // multiple definitions and declararions int _c, _d45, e; cout << b123 << endl; return 0; }

Variable Initialization:

Variable initialization is the process of assigning a value to the variable.

• = sign is used to initialize a variable
• The variable name is written on the left side of = and the value is given on the right side of =.
• Compiler allocated some memory to the variable when it is declared.

Syntax

type_ name variable=value;

• type_name: indicates the data type of the variable
• variable: name of the variable
• =  assignment operator used to initialize a variable
• value: value to initialize a variable

Example

#include <iostream> using namespace std; int main() { int a = 10; int b; cout << " value of variable a : "<< a; // static initialization cout << "\nEnter the value of variable b : "; // dynamic initialization cin >> b; cout << "\n value of variable b : "<< b; return 0; }

Output

value of variable a : 10 Enter the value of variable b : 18 value of variable b : 18

CONSTANTS IN C++

• Constants are those quantities that cannot be changed during program execution.
• It is used in the program wherever it is needed.

There are two common types of constants in C++

1. Literal constant
2. Symbolic constant

Literal constant

It is typed directly in the program and used when needed. Example

• cout<<” Hi guys”;

The following statement contains "Hi guys" string literal constant.

• int age = 19;

Age is an integer variable and 19 is a literal constant.

TYPES OF LITERAL CONSTANTS: 

There are 5 common types of literal constants are used in C++

• Integer constant
• Floating-point constant
• Character constant
• String constant
• Bool constant

Integer literal constant

It can be a decimal, hexadecimal or octal constant. Examples:

• 85         // decimal
• 0213       // octal
• 0x4b       // hexadecimal
• 30         // int
• 30u        // unsigned int
• 30l        // long
• 30ul       // unsigned

 Floating-point literals

Floating-point literal constant contain four parts

• Integer part
• Decimal part
• Fractional part
• Exponent part

Decimal forms include a decimal point, exponent or both. Exponent forms include integer part, fractional part or both

Examples

• 3.14159       // Legal
• 314159E-5L    // Legal
• 510E          // Illegal: incomplete exponent
• 210f          // Illegal: no decimal or exponent
• .e55          // Illegal: missing integer or fraction

Character constants

• These constants are enclosed in single quotes
• Upper case letters are stored in wchar_t type and lower case letters are stored in char type
• A character literal can be a simple character (e.g., 'x'), an escape sequence (e.g., '\p’), or a universal character (e.g., '\u0C0').
• The characters with backslash have special meanings. These characters with a backslash are given below.

Escape sequence	Meaning
\\	\ character
\'	' character
\"	" character
\?	? character
\a	Alert or bell
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\ooo	Octal number of one to three digits
\xhh . . .	Hexadecimal number of one or more digits

 

Example

#include <iostream> using namespace std;   int main() { cout << "Hello\tWorld\n\n"; return 0; }

Output

Hello   World

String constants

They are enclosed in double-quotes. It may contain

• Characters
• Escape sequence
• Universal character

String literals are used to break long lines into multiple lines.

Examples

"hello, dear" "hello, \ dear" "hello, " "d" "ear"

Program for defining a constant

#include <iostream>

using namespace std;

#define VAL1 20

#define VAL2  6

#define Newline '\n'

int main()

{

   int tot;

   tot = VAL1 * VAL2;

   cout << tot;

   cout << Newline;

}

Programs

#include <iostream> using namespace std;   #define LENGTH 5 #define WIDTH  20 #define NEWLINE '\n'   int main() { int area;   area = LENGTH * WIDTH; cout << area; cout << NEWLINE; return 0; } Program # 2 #include <iostream> using namespace std;   int main() { const int SIDE = 40; int area; area = SIDE*SIDE; cout<<"The area of the square with side: " << SIDE <<" is: " << area << endl; return 0; }

Bool constants

Three keyword literals exist in C++: true, false and nullptr:

• For Boolean variables, we have true or false literals/ constants.
• nullptr indicates the null pointer value.

1 2 3

bool foo = true; bool bar = false; int* p = nullptr;

Symbolic constants 

•  It is the Symbolic name given to the Symbolic values that cannot be changed
• A Symbolic constant PI having the value 3.141593 is used where needed and its value can not be changed.

There are two ways by which Symbolic constants can be derived.

1. const Qualifier
2. define Directive

The syntax for const Qualifier

const <Data_Type> <Variable_Name>

The syntax for define directive

<Return_Type> <Function_Name>() const

Example

#include <iostream> using namespace std;   const int a = 100;    // Const Variable   class TestConst { public: void display() const   // Const Function/ define directive { cout << "Value of a in the const function is " << a; } };   int main () { Test int1; int1.display(); cout << a; return 0; }

Comparison table for Constants and Variables

We have discussed above the clear understanding of variables, their types and some programs to make grip on the topic. We have also discussed constants and their types and some programs to make ideas clear. At the end, we make a clear comparison between constants and variables.

In the next section, we will discuss operators, expressions and comments in C++. Till then take care and have fun. Thanks for reading.

C++ Data Types

In the previous section, we have had an overview of a detailed Introduction to C++. Today, we will have a look at the data types in C++. It's our 2nd tutorial in the C++ programming language series.

In the previous tutorial, we have seen the basics of C++ and have also discussed a small code. We have discussed various programming terms in the previous tutorial and from now on, we are going to discuss those terms in detail. So, today's lecture is on Data Types in C++, let's get started:

C++ Data Types

A  data type defines the type and the set of operations that can be performed on the data. Various types of data are manipulated by the computer. The data is given as an input to the program. According to the program's set of instructions, data is processed and then output is returned on the screen. Before designing the actual program data, its type and operations performed on it are defined and used to process the data. At the start of the program, the type of each data value is identified. Various data types are provided by C++ and the computer’s memory allocates each data type differently.

Types of data types in C++

1. Built-in data types
2. derived data types 
3. user-defined data types

Built-in Data Types in C++

• Integral, floating-point and void data types are provided by C++ as built-in data types.
• The integral and floating-point data types can be treated with different types of modifiers.
• The size or range of data type is changed by using these modifiers.
• Short, long, signed and unsigned are various modifiers.

Three main built-in data types provided by C++ are:

1. Integral data type

• Integer data type: keyword int is used to express integer data type.
• It normally requires 4 bytes of memory and ranges from -2147483648 to 2147483647.

long b = 4523232; long int c = 2345342; long double d = 233434.56343; short d = 3434233; // Error! out of range unsigned int a = -5;    // Error! Used for storing only +ive  numbers and 0

Example

 

Character data type in C++

• Characters are stored by using character data type.
• Char is used to representing character data type.
• It normally requires 1 byte of memory.

• char test = 'h';
• As each character is assigned by a unique ASCII code which is an integer so that’s why characters are included in integral data type.
• When we store a character in memory, we actually store a unique numeric code associated with that character in memory.
• And when the computer is instructed to print characters, it basically prints characters associated with the numeric code.
• Here's the chart showing ASCII codes of alphabetical characters:

2. Floating data types in C++:

• Variables holding real numbers are defined by using floating-point data type. In C++  three data types are used to represent floating-point numbers.

1. float
2. double
3. Long double

float area = 64.74; double volume = 134.64534;

• Values having floating-point types are expressed in terms of precision and range.
• The accuracy in the fractional part of the value is precision.
• Range: it is for the range of fractions and numbers.
• The floating point number is stored as mantissa E or the power of 10.

3. Void data type

• The meaning of void is without any value and is used where functions do not return any value.
• A function does not take any argument when the void is used to define an empty parameter list and a function does not return any value when it is used to return value to the function.
• 0 bytes of memory is allocated to it and hence it cannot store anything. As a result, it cannot be used to declare simple variables but it can be used to define generic pointers.

C++ Void Pointer

#include <iostream> using namespace std; int main() { void* ptr; float f = 2.3f;   // assign float address to void ptr = &f;   cout << &f << endl; cout << ptr << endl;   return 0; }

Output

0xffd117ac 0xffd117ac

Bool and wcha_t:

• In C++, Boolean and wide-character data types are also used.
• Boolean values are defined by bool data type.
• Bool data type contains only 2 integers 0 and 1.
• False is represented by 0 and 1 is used to represent true.
• Only 1 bit of storage is required by bool data type.
• As it is stored as an integer so it can be considered as an Integral data type. The results of logical operations performed on data are represented by the bool data type.

bool cond = false;

• In addition to char data type, wchar_t is used to store 16- bit wide characters in C++. Large character sets are allocated with non-English languages so wchar-t is used to store wide characters.

wchar_t test = $# // storing dollar and hash character;

User-Defined Data Types in C++

C++ provides various user-defined data types

• structures, 
• unions, 
• enumerations and
• classes.

Structure, Union and class

Important features of the C language are structures and unions. Similar or dissimilar data types assigned a single name are grouped by structure and union. However, in C++ the concept of structure and union is modified by adding some new features to provide support to object-oriented programming. Class is defined as a new user-defined data type by C++ and it forms the basis of object-oriented programming. A class functioned as a template that can be used to define the data and functions that are included in an object of a class. Classes are declared using the keyword class. The object of the class can be created when the class is declared.

Enums in C++

A set of integer constants that are named and specify all the values that can be assigned to variables Enumerators are the set of these permissible values. For example, consider the statement.

enum Colour{red, green, blue, white};       // declaring an enum type

• In this statement, an enumeration data-type color (Colour is a tag name), consisting of enumerators red, green, blue and white is declared.
• These enumerators represent only integer values, so any arithmetic operation can be performed on them.
• By default, the first enumerator in the enumeration data type will have the value zero.
• The value of the next enumerators is increased by one. Hence,
  • the value of red is 0,
  • the value of green is 1
  • the value of blue is 2 and
  • the value of white is 3.

We can also assign values explicitly to enumerators as shown here.

enum country {US, UN=2, India, china} ;

• Value for the US is 0 by default in this declaration
• the value of UN is 2
• Russia is 3 and
• China is 4

When enum is declared then its variables assign the values specified in enum.

country country1, country2;

For example, consider these statements.

• Country1 Pakistan; // valid
• country2 China; // invalid

Int data types can not be assigned to enumerators because they are treated as integers.

Derived Data Types in C++

Derived data types are derived from built-in data types. C++provide 4 major derived data types that are

• arrays, 
• Functions, 
• references and
• pointers.

Array

• The set of elements having the same data type and same name formed an array.
• In memory, all the elements are stored one after another location.
• An index or subscript is used to access an element.
• The position of the element is indicated by the subscript value.

Declaring Arrays:

• Syntax to declare a one-dimensional array:

//intExp indicates number of elements dataType arrayName[intExp]; //declares array num containing 4 elements of type int: //num[0], num[1], num[2],and num[3] int num[4];

Accessing Array Elements:

• Syntax to access array element:

 

// intExp is used to specify position array Name[intExp]   //fourth element in array num num[3];

One dimensional array example

1. Initialize
2. Input
3. Output
4. Sum and Average
5. Find largest element value
6. Find the smallest element value

  // name of the constant is initialized const int arraySize=5;   double list[arraySize];   //initialize 7 variables int i=0; double smallest=0.0; double largest=0.0; double sum=0.0; double average=0.0; int maxi=0; int mini=0;   //1. Array us initialized for (i=0; i < arraySize; i++) list[i]=0.0;   //2. Give value for each element in array list, beginning w/first element for (i=0; i < arraySize; i++) cin >> list[i];   //3. Resulted value for each element in array list, beginning w/first element for (i=0; i < arraySize; i++) cout << list[i] << " ";   //4. Sum and Average elements in array list, and display for (i=0; i < arraySize; i++) sum = sum + list[i]; average = sum / arraySize;   cout << "Sum = " << sum; cout << "\nAverage = " << average;   //5. find largest element value in array list, and display for (i=0; i < arraySize; i++) if (list[maxi] < list[i]) maxi = i; largest = list[maxi];   cout << "\nLargest = " << largest;   //6. find smallest element value in array list, and display for (i=0; i < arraySize; i++) if (list[mini] > list[i]) mini = i; smallest = list[mini];   cout << "\nSmallest = " << smallest;

 Function in C++

• The function is used to carry out a specific well-defined task. It is a self-contained program segment.
• In C++ one or more functions can be used in a program and can be invoked from the other parts of the program when needed.

#include <iostream> using namespace std; int fact(int n); // function prototype   int main(){ int nv,ans; cout<<" Input n:"; cin>> nv; ans = fact(nv);// calling a function cout<<"Answer is:"<<ans<<endl; }

int fact(int n){  // int to another int int ans =1; for(int i= 3; i<= n; i++) ans *=i; return ans are; // function providebanswer to the caller }

function prototype, calling main program and the complete function definition shown in the above program

C++ Reference

The alternate name of the variable is a reference. So we can say that a reference is an alias for the variable in the program. Both variable and reference allocate the same memory location so they can be interchangeably used in a program. When we make changes in variables, these changes are also made in reference and vice versa. –  reference type variable in C++ is treated as a constant pointer that can be dereferenced.

• Constant reference type variable must be initialized first and can not be used as a reference to other variables.
• Ampersands (&) are used with reference type variables. For example,

int result  = 0; int &ref_result =  result; … ref_result =  100;

C++ Pointers

• The variable which can be used to store the memory address of another variable is called a pointer.
• Memory is used dynamically by pointers.
• In run time, memory can be allocated and de-allocated with the use of pointers which increases the efficiency of the program.
• Assignment and dereferencing are two major operations performed by pointers. Assignment operation assigns a value to the pointer and dereferencing takes reference by indirection technique.
• If ptr is a pointer variable with the value 7080,  and the cell whose address is 7080 has the value 206, then the assignment j = *ptr sets j to 206.
• The assignment operation j = *pta

• Pointers should be used with care because they are flexible.
• Used for management addressing and dynamic storage.
• Pointer arithmetic in C++ makes them more interesting than other programming languages.
• The asterisk (*) is used for dereferencing operation, and the ampersand (&) for producing the address of a variable. For example, in the code

int *ptr; int count, init; … ptr = &init; count =  *ptr

• single assignment statement can take place the value of two assignment operators.

count =  init;

Example: Pointer Arithmetics in C++

int list[10]; int *ptr; ptr = list;

• *(ptr+5)   is equivalent to list[5]   and  ptr[5] *(ptr+i)   is equivalent to  list[i]   and  ptr[i] –
• Domain type is not needed to be fixed.

So, that was all for today. I hope you have enjoyed today's lecture. In the next tutorial, we will discuss the variables and constants in C++. Stay tuned !!! :)