DEV Community: Isaac Smith

I try to explain CS concepts in simple terms

Isaac Smith — Tue, 05 Oct 2021 09:22:03 +0000

Algorithm

A finite set of instructions called an algorithm is utilized to solve a certain task. Because they are designed to solve a problem, most computer programs are also considered algorithms. Algorithms are an important component of computers; they are used in anything from solving mathematical problems to recommendation systems. Algorithm efficiency is determined by how much memory they consume and how long it takes them to finish a task. Searching and sorting algorithms are the most popular types of algorithms. The linear search algorithm is an example of an algorithm: This technique is used to find a specific item in a sorted list of items, such as a phone book. The algorithm checks the first item to see if it's the one we're looking for, and if it's not, it moves on to the next and checks again. This is a very slow process, which is terrible for an algorithm. There are algorithms that use a better search technique, such as divide and conquer.

Control structure

A control structure is a piece of code that enables programs to make choices while they are running. Programs don't always run in a straight path; a change in a value can cause the program to branch or even skip entire blocks of code. Conditionals and loops are the most basic control structures in programming. Conditionals, which are denoted by If or If-Else statements, execute a block of code when a given condition is met, either by user input or by the internal state of the program at runtime. When a specific condition is met, either by user input or by the program's internal state, loops cause the program to repeat the execution of a block of code a given number of times. Loops are useful because they allow you to run a block of code as many times as you need. The keywords For and While are used to indicate loops.

Class hierarchy

In object-oriented programming, a class hierarchy is a concept that defines the number of child classes a parent class can have. Assume we have a class that represents an automobile. The Automobile class can have attributes and methods that define the basic components of a car, such as the body material, the engine, the tires, and the seats. Now we can build a new instance of the Car class and have a working car model, but what if we wanted to make a different car with a different engine, tires, and entertainment systems? Then we'd have to make a new class named Lamborghini that inherits the Car class's attributes and methods. Now we may either overwrite the parent class's properties and methods or create new ones that will only belong to the Lamborghini class. The call is sent up to the parent class when we call a method built in the Car class from the Lamborghini class. This is referred to as upcasting. Many child classes can be formed, either from the parent class or from another child class, resulting in a tree of classes with their own attributes and methods.

Flowchart

A flowchart is a diagram that depicts the stages involved in solving an issue. Algorithms can be described using flowcharts in a step-by-step manner. A rectangular or diamond-shaped box can be used to connect the steps in a flowchart chart, and an arrow can be used to connect them to another step. Flowcharts can be used to document or assess a process in addition to describing algorithms. The diamond boxes normally indicate a decision, while the rectangle bounding boxes usually reflect an activity. A cross-functional flowchart is one in which the chart is broken into separate vertical or horizontal segments that describe the control of various organizational units. A cross-functional flowchart enables the author to correctly identify who is responsible for executing an action or making a decision, as well as to explain how each organizational unit is responsible for different aspects of a single process.

C++: A concise introduction to functions

Isaac Smith — Mon, 04 Oct 2021 13:14:47 +0000

A function is a piece of code that performs a specific task and gives a program modularity. Multiple functions can be included in a program, making complex programs easier to manage and understand. I am aware of two types of functions: standard library functions and user-defined functions. The functions that come prepackaged with the programming language are known as standard library functions, whereas user-defined functions are functions that are created by the programmer. When a function is called, the code defined in its body is executed. The following is a general definition of a function

returnType functionName (parameter0, parameter1) {
    // Function body

    // return statement
}

It is possible to declare a function with or without parameters. A parameter is a value passed into a function when it is declared. When calling a function, the type of arguments passed into it should match the corresponding parameters defined in the function declaration. This is a function that calculates velocity given distance and time.

// Function declaration
int velocity(int distance, int time);

// Function definition 
int velocity(int distance, int time) {

    return distance / time;
}

Functions can have or not have a return statement. When returning a value, the return keyword is used. To call a function, we write the function name at the point where we want to call it and, if necessary, pass arguments to it. The name of the function is specified in the function declaration, and the body of the function is specified in the function definition.

functionName(argument0, argument1);

Functions can have default parameters; if a function with default
parameters is called without passing arguments to it, it will use the default parameters. This function can add two or three numbers.

// Function declaration
int add(int i, int j, int = 0);

// Function definition
int add(int i, int j, int k) {

    return i + j + k;
}

The default parameters of a function can be overwritten when the function is called. In C++, we can call functions either by value
or by reference.

Advantages of using Functions

Using functions cuts down on coding time. Because all the subtasks are divided down into their own functions, functions make building huge programs easier to write and debug. The same functions that a programmer defines in different portions of a program can be reused. This cuts down on the amount of code a programmer has to write while simultaneously shortening development time.

Because there is a separation of concerns in the software, using functions makes testing easy. Because separate functions perform different jobs, a programmer can test for problems because the desired result is obvious. Because there is a single point of failure and difficulty reasoning around it, testing a monolithic program may fail. Functions are a convenient approach to create well-structured, testable applications.

Maintainability is improved by using functions. If a program is split down into smaller bits, a programmer can simply adjust it. A program that has been broken down into functions is easier to navigate and allows the programmer to avoid scanning the entire program for a single line of code that has to be changed.

The use of functions improves the reliability of a program. This is due to the code's modularity, which allows for easy testing and debugging, as well as the code's maintainability, which allows the programmer to alter parts of the code without breaking something on another line or affecting the program's structure. It's usually best to divide diverse activities and processes into their own functions when designing sophisticated software.

Happy coding.

C++: A concise introduction to structures

Isaac Smith — Sun, 03 Oct 2021 19:19:07 +0000

A structure is a collection of variables of different data types stored in a block of memory under a single name, allowing the different variables to be accessed via a single pointer or by the struct declared name, which returns the same address. This is a convenient way to keep related information together. It is similar to a class in that both contain a collection of data of various datatypes. Structures are known as compound data types because they are made up of several different variables that are logically connected. By default, struct members in C++ are public. The general structure declaration format is

struct structureName {
    datatype member0;
    datatype member1;
    datatype member2;
};

Memory is not allocated when a structure is created. After a variable is added to the struct, memory is allocated. The struct datatype cannot be treated like a built-in data type in C++. Inside the structure body, static members cannot be created. Constructors cannot be created within structures. The dot (.) operator is used to access structure members, and the arrow (→) operator is used to access structure members if we have a pointer to a structure.
Here's an example of a struct.

struct Album {
    string title;
    string artist;
    float cost;
    int quantity;
};

int main() {
    struct Album song;
    song.title = "Summer-The four seasons";
    song.artist = "Antonio Vivaldi";
    song.cost = 50.0
    song.quantity = 10000

    return 0;
}

The structure Album is declared here, which consists of four members: title, artist, cost, and quantity. A structure variable song is defined within the main function. The appropriate data is then entered into it.

Happy Coding.

C++: A concise introduction to Arrays

Isaac Smith — Sun, 03 Oct 2021 18:54:53 +0000

An array is a collection of elements (values or variables) of the same type that are stored in contiguous memory locations and may be accessed individually using a unique identifier's index. The memory addresses are all next to one other, and the array's size is determined by the number of elements. The first or base address is the memory address of an array's first element. An index, which is usually a non-negative scalar number, is used to select individual objects. The index of an array's initial element is almost always zero. The array value is mapped to a stored object via an index. The following is an example of the mapping.

map(arrayName, index) → element

An example of an array declaration.

datatype arrayName [elements];

There are three types of arrays in C++; one-dimensional, two-dimensional and multidimensional array.

A one-dimensional is also called a linear array.

int myArray0[5] = {1, 2, 3, 4, 5};

In a two dimensional array there are 'x' number of rows and 'j' number of columns. They are sometimes called matrices or tables.

int myArray1[2][2] = {{1, 2}, {3, 4}};

A multidimensional array can have any number of dimensions.

int myArray2[2][2][2][2] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}}

Arrays can be used to implement other data structures such as lists, hash tables, stacks and strings.

Happy Coding.