DEV Community: Lubna Fathima

Variables and Data Types in C++ : Part 2

Lubna Fathima — Fri, 20 Jan 2023 05:18:57 +0000

Introduction to Variables

A variable is a storage place that has some memory allocated to it. It is used to store some form of data.
Different types of variables require different amounts of memory.

Variable Declaration

In C++, we can declare variables as follows:

data_type: Type of the data that can be stored in this variable. It can be int, float, double, etc.
variable_name: Name given to the variable.

data_type variable_name; 

Example: int x;

In this way, we can only create a variable in the memory location. Currently, it doesn’t have any value. We can assign the value in this variable by using two ways:

By using variable initialization.
By taking input

Here, we can discuss only the first way, i.e., variable initialization. We will discuss the second way later.

data_type variable_name=value; 

Example: int x = 20;

Rules for defining variables in C++

You can’t begin with a number. Ex- 9a can't be a variable, but a9 can be a variable.
Spaces and special characters except for underscore(_) are not allowed.
C++ keywords (reserved words) must not be used as a variable name.
C++ is case-sensitive, meaning a variable with the name ‘A’ is different from a variable with the name ‘a. (Difference in the upper-case and lower-case holds true).

C++ Keywords

Introduction to Data Types

All variables use data type during declaration to restrict the type of data to be stored.

Therefore, we can say that data types tell the variables the type of data they can store.

Pre-defined data types available in C++ are:

int: Integer value
unsigned int: Can store only positive integers
float, double: Decimal number
char: Character values (including special characters)
unsigned char: Character values
bool: Boolean values (true or false)
long: Contains integer values but with the larger size
unsigned long: Contains large positive integers or 0
short: Contains integer values but with smaller size

Table for datatype and its size in C++:

(This can vary from compiler to compiler and system to system depending on the version you are using)

Examples:

int price = 5000;// Integer (whole number)

float interestRate = 5.99f; // Floating point number

char myLetter = 'D'; // Character

bool isPossible = true; // Boolean 

string myText = "Coding Ninjas"; // String

auto keyword in c++

The auto keyword specifies that the type of the declared variable will automatically be deduced from its initializer.
It would set the variable type to initialize that variable’s value type or set the function return type as the value to be returned.

Example:

auto a = 11 // will set the variable as int type

auto b = 7.65 //will set the variable b as a float 

auto c = "abcdefg" // will set the variable c as string

Scope of Variables

The scope of a variable refers to the region of visibility or availability of a variable i.e the parts of your program in which the variable can be used or accessed.
There are mainly two types of variable scopes: Local Scope and Global Scope

Local Scope

Variables declared within the body of a function or block are said to have local scope and are referred to as local variables.

They can be used only by the statements inside the body of the function or the block they are declared within. Example:

void person () { 
string gender = "Male"; 
//This variable gender is Local to the function person () 
//and cannot be used outside this function.
}

Global Scope

The variables whose scope is not limited to any block or function are said to have global scope and are referred to as 'global variables.
Global variables are declared outside of all the functions, generally on the top of the program, and can be accessed from any part of your program.
These variables hold their values throughout the lifetime of the program. Example:

#include <iostream> 
using namespace std; 
// Global variable declaration: and can be used anywhere in code 
int g;
int main() {
    g=10; // Using global variable 
    cout << g;
    return 0;
}

Types of Variables, Overflow and Underflow

There are three types of variables based on the scope of the variable in C++ -

Local Variables
Instance Variables
Static Variables

Local Variables

The variables declared within the body of a function or block are known as local variables and are created(occupy memory) when the program enters the block or makes a function call.
The local variables get destroyed(memory is released) after exiting from the block or returning from the function call.
They can be used only by the statements inside the body of the function or the block they are declared within. Example:

void function () { 
//Local variable marks 
int marks = 90; 
marks = marks + 2;
cout << "Student obtained "<<marks<< "marks. "
return; 
}
Output: Student obtained 92 marks.

Instance variables

Instance variables are non-static variables that belong to an instance of a class and are declared in a class outside any method, constructor, or block.
These variables are created when an object of the class is created and destroyed when the object is destroyed and are accessible to all the constructors, methods, or blocks in the class.
Each object of the class within which the instance variable is declared will have its separate copy or instance of this variable.
Unlike local variables, we may use access specifiers for instance variables. Example:

class A { 
    int a; // by default private instance variables 
    int b; 
    public:
        int c; // public instance variable 
    Void function () { 
        a 10; 
        cout << a;
    }
};

Static Variables

Static variables are declared using the keyword 'static, within a class outside any method, constructor, or block.
Space is allocated only once for static variables i.e we have a single copy of the static variable corresponding to a class, unlike instance variables.
The static variables are created at the start of the program and get destroyed at the end of the program ie the lifetime of a static variable is the lifetime of the program.
Static variables are initialized only once and they hold their value throughout the lifetime of the program. Example:

class A { 
    static int var; //static variable 
    Void func() { 
        ++var;
    }
};

Overflow and Underflow

Overflow occurs when we assign a value to more than its range, and Underflow is the opposite of overflow.
In the case of overflow and underflow, the C++ compiler doesn't throw any errors.
It simply changes the value.
For example, in the case of an int variable, the maximum value of the int data type is 2,147,483,647 (NT MAX) and after incrementing 1 on this value, it will return -2,147,483,648 (INTMIN). This is known as overflow.
The minimum value of the int data type is -2,147,483,648 (INT MIN) and after decrementing 1 on this value, it will return 2,147,483,647 (INT MAX). This is known as underflow. Example:

#include <iostream> 
using namespace std; 
int main() { 
    int x = INT_MAX; //2147483647 
    int y = INT_MIN; //-2147483648 
    x = X + 1; 
    y =y- 1; 
    cout < x << endl; 
    cout < y;
}
Output: 
-2147483648 
2147483647

Typecasting

Converting an expression of a given data type into another data type is known as type-casting or type-conversion.

There are two types of type conversions:

- Implicit Type Conversion

- Explicit Type Conversion

Implicit Type Conversion

It is automatically performed by the compiler itself to ensure that the calculations between the same data types take place and avoid any loss of data.
Such types of conversions take place when more than one data type is present in an expression.
The rule associated with implicit type conversions involves upgrading the data type of all the variables to the data type of the variable with the "largest data type".
The order of automatic type conversion or the sequence for smallest to largest data type(left to right) for this type conversion is given as:

bool-> char -> short int -> int -> unsigned int -> long -> unsigned-> long long -> float-> double -> long double

Example:

#include <iostream> 
using namespace std; 
int main() { 
    int number = 200;  
    char letter = 'c'; 
    float dec = 0.7;
    int res1 = number + letter; // here Letter is implicitly converted to int and its va // ASCII value of c i.e. 99 
    cout << res1 << " "; 
    float res2 = res1 + dec; // here resi is implicitly converted to float. 
    cout < res2; 
}
Output: 299 299.7

Explicit Type Conversion:

This process is also called typecasting, and it is user-defined.
Here the user can typecast the result to make it of a particular data type which may lead to data loss and is also known as forceful casting.

Syntax:

(type) expression 
Example: 
int main() { 
    double dbl = 5.6; 
    int res = (int)dbl + 10; // Here dbl is explicity con verted to int i.e value of dbl becomes 5. 
    cout <<"Result = " << res;
}

Introduction to C++ : Part 1

Lubna Fathima — Sat, 14 Jan 2023 12:39:55 +0000

Introduction, Features and Uses of C++

Introduction

C++ is a general-purpose programming language and is widely used nowadays for competitive programming.
It has imperative, object-oriented, and generic programming features.
C++ runs on lots of platforms like Windows, Linux, Unix, Mac, etc.
It can be used to develop operating systems, browsers, games, and so on.
This makes C++ powerful as well as flexible.
You can run programs and practice them on your local desktop, Using one of these compilers: Code blocks, VS Code, Dev C++, Atom, and many more.

Features of C++

Simple
Portability
Powerful and Fast
Rich Library
Platform Dependent
Mid-level programming language
Structured programming language
Object-Oriented
Case Sensitive
Compiler Based
Syntax based language
Pointers
Dynamic Memory Management

Simple:

C++ is a simple language because it provides a structured approach (to break the problem into parts), a rich set of library functions, data types, etc.
It allows us to follow both procedural as well as functional approaches to design our flow of control.

Portability:

It is the concept of carrying the instruction from one system to another system.
In C++ language .cpp file contains source code, and we can also edit this code.
.exe file contains the application, which is the only file that can be executed. W
When we write and compile any C++ program on the Windows operating system, it efficiently runs on other window-based systems.

Powerful:

C++ is a very powerful programming language, and it has a wide variety of data types, functions, control statements, decision-making statements, etc.
C++ is a fast language as compilation and execution time is less.
Also, it has a wide variety of data types, functions & operators.

Rich Library:

C++ library is full of in-built functions that save a tremendous amount of time in the software development process.
As it contains almost all kinds of functionality, a programmer can need it in the development process.
Hence, saving time and increasing development speed.

Platform Dependent:

Platform-dependent language means the language in which programs can be executed only on the operating system where it is developed & compiled.
It cannot run or execute on any other operating system. E.g., compiled programs on Linux won’t run on Windows.

Mid-level programming language:

C++ can do both low-level & high-level programming.
That is the reason why C++ is known as a mid-level programming language.

Structured programming language:

C++ is a structured programming language as it allows to break off of the program into parts using functions.
So, it is easy to understand and modify.

Object-oriented:

C++ is an object-oriented programming language.
OOPs make development and maintenance easier.
whereas, in Procedure-oriented programming language, it is not easy to manage if code grows as project size grows.
It follows the concept of oops like polymorphism, inheritance, encapsulation, abstraction.

Case sensitive:

C++ is a case-sensitive programming language.
In C++ programming, 'break and BREAK' both are different.

Compiler-Based:

C++ is a compiler-based language, unlike Python.
C++ programs used to be compiled, and their executable file is used to run it due to which C++ is a relatively faster language than Java and Python.

Syntax-based language:

C++ is a strongly typed syntax-based programming language.
If any language follows the rules and regulations strictly, it is known as a strongly syntax-based language.
Other examples of syntax-based languages are C, C++, Java, .net etc.

Pointer:

C++ supports pointers that allow the user to deal directly with the memory and control the programmer.
This makes it very suitable for low-level tasks and very complicated projects.
It is known to increase the speed of execution by decreasing the memory access overhead.

Dynamic Memory Management:

It supports the feature of dynamic memory allocation.
In C++ language, we can free the allocated memory by calling the free() function.
These features are missing in languages like C.

Uses of C++

There are several benefits of using C++ because of its features and security.

below are some uses of C++ Programming Language

Operating Systems:

One of the key requirements of an Operating System is that it should be very fast as it is responsible for scheduling and running the user programs.
The strongly typed and fast nature of C++ makes it an ideal candidate for writing operating systems.
Also, C++ has a vast collection of system-level functions that also help in writing low-level programs.
Microsoft Windows or Mac OS X, or Linux all operating systems have some parts programmed in C++.

Games:

Again since most, games need to be faster to support smooth gameplay, C++ is extensively used in game design.
C++ can easily manipulate hardware resources, and it can also provide procedural programming for CPU-intensive functions.

Browsers:

With the fast performance of C++, most browsers have their rendering software written in C++.
Browsers are mostly used in C++ for rendering purposes. Rendering engines need to be faster in execution as most people do not like to wait for the web page to be loaded.

Libraries:

Many high-level libraries use C++ as the core programming language.
For example, TensorFlow uses C++ as the back-end programming language.
Such libraries required high-performance computations because they involve multiplications of huge matrices to train Machine Learning models.
As a result, performance becomes critical.
C++ comes to the rescue in such libraries.

Graphics:

C++ is widely used in almost all graphics applications that require fast rendering, image processing, real-time physics, and mobile sensors.

Cloud/Distributed Systems:

Cloud storage systems use scalable file systems that work close to the hardware.
Also, the multi-threading libraries in C++ provide h*igh concurrency and load tolerance.*

Embedded Systems:

C++ is closer to the hardware level, and so it is quite useful in embedded systems as the software and hardware in these are closely coupled.
Many embedded systems use C++, Such as smartwatches, MP3 players, GPS systems, etc.

Compilers:

Compilers of various programming languages use C++ as the back-end programming language.

How to implement a code in C++

Headers in C++

C++ code begins with the inclusion of header files.
There are many header files available in the C++ programming language.
So, what are these header files? The names of program elements such as variables, functions, classes, and so on must be declared before they can be used.
For example, you can’t just write x = 42 without first declaring variable x as:
```
int x = 42;
```
The declaration tells the compiler whether the element is an int, a double, a float, a function, or a class.

Similarly, header files allow us to put declarations in one location and then import them wherever we need them.

This saves a lot of typing in multi-file programs.

To declare a header file, we use the #include directive in every .cpp file.

This #include is used to ensure that they are not inserted multiple times into a single .cpp file.

Now, moving forward to the code:

#include <iostream>
using namespace std;

iostream stands for Input/Output stream, meaning this header file is necessary to take input through the user or print output to the screen. This header file contains the definitions for the functions:
- cin: used to take input
- cout: used to print output
namespace defines which input/output form is to be used. You will understand these better as you progress in the course.
Note: semicolon (;) is used for terminating a C++ statement. i.e., different statements in a C++ program are separated by a semicolon.

main() function

int main() { 
    Statement 1; 
    Statement 2; 
    ... 
}

int main()

int: This is the return type of the function. You will get this thing clear once you learn about Functions.
main(): This is the portion of any C++ code inside which all the commands are written and executed.
- This is the line at which the program will begin executing. This statement is similar to the start block of flowcharts.
{}: All the code written inside the curly braces is said to be in one block, also known as a particular function scope. Again, things will be clear once you learn about Functions

Compiler and Run

For compiling and running a CPP program in Linux following are the command lines:

Compile: g++ Filename.cpp 
Run or execute: ./a.out

For compiling and running a CPP program in Windows following are the command lines:

Compile: gcc Filename.cpp 
Run or execute: filename

Macros and Comments in C++

Macros in C++

Macros are a piece of code in a program that is given some name.
Whenever the compiler encounters this name, the compiler replaces the name with the actual piece of code.
The '#define' directive is used to define a macro.
Note: There is no semicolon(:) at the end of the macro definition.

#include <iostream>
using names pace std;
//macro definition
#define LIMIT 5

int main() {
    for (int i 0; i < LIMIT; i++) {
        cout << i <<" ";
    }
    return 0;
}
/*    Output:
      e1 2 3 4     */

Macros with arguments:

We can also pass arguments to macros.
Macros defined with arguments work similarly as functions. Example:

#include 
using namespace Std;
// macrO wth parameter 
#define Area(l, b)(* b) 
int main() {
    int l = 10, b =5, a;
    a = Area(1, b); 
    cout << "The Area of the rectangle is: " << a; 
    return 0;
}
/*    Output:
      The area of the rectangle is: 50    */

Comments in C++

C++ comments are hints that a programmer can add to make their code easier to read and understand.
They are completely ignored by C++ compilers.

There are two ways to add comments to code:

// - Single Line Comment
/* */ - Multi-line Comments

Example: Single-line comment

 #include <iostream>
using namespace std;
int main() {
    // This is a comment 
    cout << "Hello World! "; 
    return 0;
}

/*    Output:
      Hello World    */

Example: Multi-line comment

 #include <iostream>
using namespace std;
int main() {
    /* This is a comment will print
    Hello World*/
    cout << "Hello World! "; 
    return 0;
}

/*    Output:
      Hello World    */

If you have read this far... Do not forget to stay tuned for Part 2 of this series.

Thank you for reading 👋