DEV Community: Bhargava-Nandanavanam

Object Oriented Programming

Bhargava-Nandanavanam — Mon, 25 Oct 2021 16:28:32 +0000

Object-oriented programming (OOP) is a fundamental programming paradigm used by nearly every developer at some point in their career. OOP is the most popular programming paradigm and is taught as the standard way to code for most of a programmers educational career.

Today we will break down the basics of what makes a program object-oriented so that you can start to utilize this paradigm in your own projects and interviews.

What is Object Oriented Programming?

Object Oriented programming (OOP) is a programming paradigm that relies on the concept of classes and objects. It is used to structure a software program into simple, reusable pieces of code blueprints (usually called classes), which are used to create individual instances of objects. There are many object-oriented programming languages including JavaScript, C++, Java, and Python.

A class is an abstract blueprint used to create more specific, concrete objects. Classes often represent broad categories, like Car or Dog that share attributes. These classes define what attributes an instance of this type will have, like color, but not the value of those attributes for a specific object.

Classes can also contain functions, called methods available only to objects of that type. These functions are defined within the class and perform some action helpful to that specific type of object.

What is Object Oriented Programming? OOP Explained in Depth
Apr 15, 2020 - 15 min read
Erin Doherty
editor-page-cover

Today we will break down the basics of what makes a program object-oriented so that you can start to utilize this paradigm in your own projects and interviews.

What is Object Oriented Programming?

For example, our Car class may have a method repaint that changes the color attribute of our car. This function is only helpful to objects of type Car, so we declare it within the Car class thus making it a method.

Class templates are used as a blueprint to create individual objects. These represent specific examples of the abstract class, like myCar or goldenRetriever. Each object can have unique values to the properties defined in the class.

Benefits of OOP

OOP models complex things as reproducible, simple structures.
Reusable, OOP objects can be used across programs.
Allows for class-specific behavior through polymorphism.
Easier to debug, classes often contain all applicable information to them.
Secure, protects information through encapsulation.

Grouping related information together to form a class structure makes the code shorter and easier to maintain.

In the dogsitting example, here’s how a programmer could think about organizing an OOP:

Create a parent class for all dogs as a blueprint of information and behaviors (methods) that all dogs will have, regardless of type.

Create child classes to represent different subcategories of dog under the generic parent blueprint.

Add unique attributes and behaviors to the child classes to represent differences

Create objects from the child class that represent dogs within that subgroup

The diagram below represents how to design an OOP program: grouping the related data and behaviors together to form a simple template then creating subgroups for specialized data and behavior.

The Dog class is a generic template, containing only the structure about data and behaviors common to all dogs.

We then create two child classes of Dog, HerdingDog and TrackingDog. These have the inherited behaviors of Dog (bark()) but also behavior unique to dogs of that subtype.

Finally,we create objects of the HerdingDog type to represent the individual dogs Fluffy and Maisel.

We can also create objects like Rufus that fit under the broad class of Dog but do not fit under either HerdingDog or TrackingDog.

Building blocks of OOP:

Next, we’ll take a deeper look at each of the fundamental building blocks of an OOP program used above:

Classes
Objects
Methods
Attributes

Operators & Arrays in C

Bhargava-Nandanavanam — Fri, 07 May 2021 13:56:08 +0000

Operators are the foundation of any programming language. Thus the functionality of the C language is incomplete without the use of operators. Operators allow us to perform different kinds of operations on operands. In C, operators in Can be categorized in the following categories:

Arithmetic Operators (+, -, *, /, %, post-increment, pre-increment, post-decrement, pre-decrement)
Relational Operators (==, !=, >, <, >= & <=) Logical Operators (&&, || and !)
Bitwise Operators (&, |, ^, ~, >> and <<) Assignment Operators (=, +=, -=, *=, etc.)
Other Operators (conditional, comma, size of, address, redirection)

Logical Operators:

They are used to combine two or more conditions/constraints or to complement the evaluation of the original condition under consideration. They are described below:

Logical AND operator: The && operator returns true when both the conditions under consideration are satisfied. Otherwise, it returns false. For example, a && b returns true when both a and b are true (i.e. non-zero).

Logical OR operator: The || operator returns true even if one (or both) of the conditions under consideration is satisfied. Otherwise it returns false. For example, a || b returns true if one of a or b or both are true (i.e. non-zero). Of course, it returns true when both a and b are true.

Logical NOT operator: The ! operator returns true the condition in consideration is not satisfied. Otherwise, it returns false. For example, !a returns true if a is false, i.e. when a=0.

Bitwise Operators:

The & (bitwise AND) in C or C++ takes two numbers as operands and does AND on every bit of two numbers. The result of AND is 1 only if both bits are 1.

The | (bitwise OR) in C or C++ takes two numbers as operands and does OR on every bit of two numbers. The result of OR is 1 if any of the two bits is 1.

The ^ (bitwise XOR) in C or C++ takes two numbers as operands and does XOR on every bit of two numbers. The result of XOR is 1 if the two bits are different.

The << (left shift) in C or C++ takes two numbers, left shifts the bits of the first operand, the second operand decides the number of places to shift.

The >> (right shift) in C or C++ takes two numbers, right shifts the bits of the first operand, the second operand decides the number of places to shift.

The ~ (bitwise NOT) in C or C++ takes one number and inverts all bits of it.

Assignment Operators:

Assignment operators are used to assigning value to a variable. The left side operand of the assignment operator is a variable and the right side operand of the assignment operator is a value. The value on the right side must be of the same data-type as the variable on the left side otherwise the compiler will raise an error.

Different types of assignment operators are shown below:

=: This is the simplest assignment operator. This operator is used to assign the value on the right to the variable on the left.

+=: This operator is a combination of + and = operators. This operator first adds the current value of the variable on left to the value on the right and then assigns the result to the variable on the left.

-=: This operator is a combination of - and = operators. This operator first subtracts the current value of the variable on left from the value on the right and then assigns the result to the variable on the left.

*=: This operator is a combination of * and = operators. This operator first multiplies the current value of the variable on left to the value on the right and then assigns the result to the variable on the left.

/=: This operator is a combination of / and = operators. This operator first divides the current value of the variable on left by the value on the right and then assigns the result to the variable on the left.

Relational operators

Relational operators are used to compare two values in order to understand the relationship of a number pair (e.g., less than, greater than, equal to, etc.) Let’s see them one by one:

Equal to operator: Represented as ==, the equal to operator checks if the two given operands are equal. If they are, it returns true. Otherwise, it returns false. For example, 5==5 will return true.

Not equal to operator: Represented as !=, the not equal to operator checks if the two given operands are equal. If they are not, it returns true. Otherwise, it returns false. It is the exact Boolean complement of the == operator. For example, 5!=5 will return false.

Greater than operator: Represented as >, the greater than operator checks if the first operand is greater than the second operand. If so, it returns true. Otherwise, it returns false. For example, 6>5 will return true.

Less than operator: Represented as <, the less-than operator checks if the first operand is lessthan the second operand. If so, it returns true. Otherwise, it returns false. For example, 6<5 will return false.

Greater than or equal to the operator: Represented as >=, the greater than or equal to operator checks if the first operand is greater than or equal to the second operand. If it is, it returns true; else, it returns false. For example, 5>=5 will return true.

Less than or equal to operator: Represented as <=, the less than or equal to operator checks if the first operand is less than or equal to the second operand. If it is, it returns true else false. For example, 5<=5 will also return true.

Arrays:

An array is a collection of data items, all of the same type, accessed using a common name.
A one-dimensional array is like a list; A two dimensional array is like a table; The C language places no limits on the number of dimensions in an array, though specific implementations may.
Some texts refer to one-dimensional arrays as vectors, two-dimensional arrays as matrices, and use the general term arrays when the number of dimensions is unspecified or unimportant.

Declaring Arrays:

Array variables are declared identically to variables of their data type, except that the variable name is followed by one pair of square [ ] brackets for each dimension of the array.
Uninitialized arrays must have the dimensions of their rows, columns, etc. listed within the square brackets.
Dimensions used when declaring arrays in C must be positive integral constants or constant expressions.

This is called a single-dimensional array. The arraySize must be an integer constant greater than zero and type can be any valid C data type. For example, to declare a 10-element array called balance of type double, use this statement

Initializing Arrays

Arrays may be initialized when they are declared, just as any other variables.
Place the initialization data in curly {} braces following the equals sign. Note the use of commas in the examples below.
An array may be partially initialized, by providing fewer data items than the size of the array. The remaining array elements will be automatically initialized to zero.
If an array is to be completely initialized, the dimension of the array is not required. The compiler will automatically size the array to fit the initialized data.

SAMPLE 1-D Array Program:

Multidimensional Arrays:

Multi-dimensional arrays are declared by providing more than one set of square [ ] brackets after the variable name in the declaration statement.

One dimensional arrays do not require the dimension to be given if the array is to be completely initialized. By analogy, multi-dimensional arrays do not require the first dimension to be given if the array is to be completely initialized. All dimensions after the first must be given in any case.
For two dimensional arrays, the first dimension is commonly considered to be the number of rows, and the second dimension the number of columns. We will use this convention when discussing two dimensional arrays.
Two dimensional arrays are considered by C/C++ to be an array of ( single dimensional arrays ). For example, "int numbers[ 5 ][ 6 ]" would refer to a single dimensional array of 5 elements, wherein each element is a single dimensional array of 6 integers. By extension, "int numbers[ 12 ][ 5 ][ 6 ]" would refer to an array of twelve elements, each of which is a two dimensional array, and so on.
Another way of looking at this is that C stores two dimensional arrays by rows, with all elements of a row being stored together as a single unit. Knowing this can sometimes lead to more efficient programs.
Multidimensional arrays may be completely initialized by listing all data elements within a single pair of curly {} braces, as with single dimensional arrays.
It is better programming practice to enclose each row within a separate subset of curly {} braces, to make the program more readable. This is required if any row other than the last is to be partially initialized. When subsets of braces are used, the last item within braces is not followed by a comma, but the subsets are themselves separated by commas.
Multidimensional arrays may be partially initialized by not providing complete initialization data. Individual rows of a multidimensional array may be partially initialized, provided that subset braces are used.
Individual data items in a multidimensional array are accessed by fully qualifying an array element. Alternatively, a smaller dimensional array may be accessed by partially qualifying the array name. For example, if "data" has been declared as a three dimensional array of floats, then data[ 1 ][ 2 ][ 5 ] would refer to a float, data[ 1 ][ 2 ] would refer to a one-dimensional array of floats, and data[ 1 ] would refer to a two-dimensional array of floats. The reasons for this and the incentive to do this relate to memory-management issues that are beyond the scope of these notes.

SAMPLE 2-D Array Program:

Advantages of Arrays:

Arrays represent multiple data items of the same type using a single name.
In arrays, the elements can be accessed randomly by using the index number.
Arrays allocate memory in contiguous memory locations for all its elements. Hence there is no chance of extra memory being allocated in case of arrays. This avoids memory overflow or shortage of memory in arrays.

Applications:
Arrays are commonly used in computer programs to organize data so that a related set of values can be easily sorted or searched.

C Programming

Bhargava-Nandanavanam — Fri, 27 Nov 2020 19:18:00 +0000

C (Programming Language)
C is a general-purpose, procedural computer programming language supporting structured programming, lexical variable scope, and recursion, with a static type system. By design, C provides constructs that map efficiently to typical machine instructions. It has found lasting use in applications previously coded in assembly language. Such applications include operating systems and various application software for computer architectures that range from supercomputers to PLCs and embedded systems.

Data Types:
In the C programming language, data types constitute the semantics and characteristics of storage of data elements. They are expressed in the language syntax in form of declarations for memory locations or variables. Data types also determine the types of operations or methods of processing of data elements.
The C language provides basic arithmetic types, such as integer and real number types, and syntax to build array and compound types. Headers for the C standard library, to be used via include directives, contain definitions of support types, that have additional properties, such as providing storage with an exact size, independent of the language implementation on specific hardware platforms.

Fundamental Data Types:
A fundamental or primitive type is a data type where the values that it can represent have a very simple nature (a number, a character or a truth-value); the primitive types are the most basic building blocks for any programming language and are the base for more complex data types.There are five types of fundamental data types

Integer
Floating
Character
Void
Boolean

Integer:
Integers are used to store whole numbers.

Floating:
Floating types are used to store real numbers.

Character:
Character types are used to store characters value.

Void:
void type means no value. This is usually used to specify the type of functions which returns nothing. We will get acquainted to this datatype as we start learning more advanced topics in C language, like functions, pointers etc.

Boolean:
In C, Boolean is a data type that contains two types of values, i.e., 0 and 1. Basically, the bool type value represents two types of behavior, either true or false. Here, '0' represents false value, while '1' represents true value.

Syntax :

Derived Data Types:
The functions that we create in a program are known as user defined functions or in other words you can say that a function created by user is known as user defined function. These are five types:

Functions
Arrays
Pointers
Unions
Structures Unions and Structures are classified as User Defined Data Types.

Functions:
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.
We can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically the division is such that each function performs a specific task.
C functions can be classified into two categories,

Library functions
User-defined functions Library functions are those functions which are already defined in C library, example printf(), scanf(), strcat() etc. You just need to include appropriate header files to use these functions. These are already declared and defined in C libraries. User-defined functions on the other hand, are those functions which are defined by the user at the time of writing program. These functions are made for code reusability and for saving time and space.

Defining a Function:
The general form of a function definition in C programming language is as follows −

A function definition in C programming 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.

Function Arguments:
If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.
Formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.
While calling a function, there are two ways in which arguments can be passed to a function

Call by Value
Call by Reference

Call by Value:
The call by value method of passing arguments to a function copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
By default, C programming uses call by value to pass arguments. In general, it means the code within a function cannot alter the arguments used to call the function.

Call by Reference:
The call by reference method of passing arguments to a function copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. It means the changes made to the parameter affect the passed argument.
To pass a value by reference, argument pointers are passed to the functions just like any other value.

Arrays:
Arrays are referred to as structured data types. An array is defined as finite ordered collection of homogenous data, stored in contiguous memory locations.
Here the words,
•finite means data range must be defined.
•ordered means data must be stored in continuous memory addresses.
•homogenous means data must be of similar data type.

Declaring Arrays:
To declare an array in C, a programmer specifies the type of the elements and the number of elements required by an array as follows

Here int is the data type, arr is the name of the array and 10 is the size of array. It means array arr can only contain 10 elements of int type.
Index of an array starts from 0 to size-1 i.e first element of arr array will be stored at arr[0] address and the last element will occupy arr[9].

Two dimensional Arrays:
C language supports multidimensional arrays also. The simplest form of a multidimensional array is the two-dimensional array. Both the row's and column's index begins from 0.
Two-dimensional arrays are declared as follows,

Pointers:
A Pointer in C language is a variable which holds the address of another variable of same data type.

Pointers are used to access memory and manipulate the address.

Pointers are one of the most distinct and exciting features of C language. It provides power and flexibility to the language. Although pointers may appear a little confusing and complicated in the beginning, but trust me, once you understand the concept, you will be able to do so much more with C language.

Address in C:
Whenever a variable is defined in C language, a memory location is assigned for it, in which its value will be stored. We can easily check this memory address, using the & symbol.

If var is the name of the variable, then &var will give it's address.

User-Defined Data Types:
A user-defined data type (UDT) is a data type that derived from an existing data type. You can use UDTs to extend the built-in types already available and create your own customized data types.There are two types if UDT’s in C Language:
1.Unions
2.Structures

Unions:
It is a collection of variables of different datatypes in the same memory location.We can define a union with many members, but at a given point of time only one member can contain a value.Unions can be very handy when you need to talk to peripherals through some memory mapped registers.

Syntax for Declaring a C union:

Note : Size of the union is the the size of its largest field because sufficient number of bytes must be reservedto store the largest sized field.

To access the fields of a union, use dot(.) operator i.e., the variable name followed by dot operator followed byfield name.

Structures:
Structure is a user-defined datatype in C language which allows us to combine data of different types together. Structure helps to construct a complex data type which is more meaningful. It is somewhat similar to an Array, but an array holds data of similar type only. But structure on the other hand, can store data of any type, which is practical more useful.

Defining a structure:

struct keyword is used to define a structure. struct defines a new data type which is a collection of primary and derived datatypes.

Syntax:
As you can see in the syntax above, we start with the struct keyword, then it's optional to provide your structure a name, we suggest you to give it a name, then inside the curly braces, we have to mention all the member variables, which are nothing but normal C language variables of different types like int, float, array etc.

After the closing curly brace, we can specify one or more structure variables, again this is optional.

Note: The closing curly brace in the structure type declaration must be followed by a semicolon(;).

Difference between Unions and Structures: