DEV Community: Haile Melaku

MeritGifts

Haile Melaku — Thu, 21 Dec 2023 19:40:59 +0000

C - argc, argv

Haile Melaku — Mon, 10 Oct 2022 13:58:06 +0000

Arguments on main are used to guide on how the program does it's job, when the programs are run in a hosted environment.
They are also used to pass the name of the file to the program.

A host environment is any OS environment that satisfy the basic requirement to be called an Operating system(os) like RAM, CPU, etc ..

Declaration of arguments on main is

int main(int argc, char *argv[]);

Exit status is used to indicate that a program completed successfully (a zero value)(exit(0);) or some error occurred (a non-zero value).

argc : is the number of the arguments supplied to the program.
arv[] : is the array pointer of arguments given to the program.

In arv[] the last value of the array or arv[argc] is null('\0').

#argc and argv

Up until now we have seen that argc is the number of argument and arv[] is array pointer of all the argument that are written on the terminal.

A really good example of argc and argv is

gcc main.c -o main

In this case the values gcc, main.c, -o and main are arguments that are passed to the gcc program using argv[].
the value of the arguments will be like

argc = 4
argv[0] = gcc
argv[1] = main.c
argv[2] = -o
argv[3] = main
argv[4] = null

Example

Output

If we ever want to make an operation on the values of the parameter argv[] use the function atoi() to convert the string to an integer also don't forget to include the library #include <stdlib.h>.

Example

output

Tip: to skip unused variable type cast the variable to void like (void)UNUSED_VAR;.

Example
If a variable in the parameter like argc, argv[] or any other variable, let's say you didn't use argc variable in the code you can skip the error of unused variable like

(void)argc;

C - Static libraries

Haile Melaku — Sun, 09 Oct 2022 14:07:59 +0000

Up until now we wore working with smaller program's,but when we create a very large program we are faced with some problem like

Increase in overall time of compilation and linking.
polluting out makefile.
polluting out directory where we placed the source files.

when we are faced with this problem's, we might look of a way of combining the source code into small units of related files.

#What Is A "C" Library

A library is a file containing several object files,used in the linking Phase of a program.

Why use Library's

Library is indexed so that it is easy to find functions, variables and others
Linking a program whose object files are ordered in libraries is faster than linking a program whose object.
Speeds up linking

We can create two types of library's

static libraries
shared (or dynamic) libraries

static libraries
Are object files that are linked into the program during the linking phase of compilation and are not used during the runtime.

During the creation of the executable file static library's are copied in the source code,so we can run the program only with the executable file.

The drawback of static linking is the size of the file will increase, maintaining update of the app is hard as the create file has everything it needs to run on it's own and we need to recompile every time we use the program.

Static library in

Windows have a .lib (library) extension
Linux have a .a (Archive) extension

Shared libraries (dynamic libraries)
Are object files that are linked into the program both during the linking phase of compilation and during the runtime.

During the compile time of the program the shared libraries are used to verifies that all the functions, variables and others required by the program, are either linked into the program, or in one of its shared libraries.

During the runtime of the program the shared libraries are loaded to memory by the program.

When we create the executable of a file the address of the shared library are stored in the final executable file.

Some drawback of dynamic linking is launching the program is slightly slower and when we recompile the program we face a problem which is the copy of the previous library is already stored in memory.

Dynamic library solves some of the problem's with static inking such as size and need for compilation.

Shard library in

Windows have a .dll (dynamic link library) extension
Linux have a .so (shard object) extension

#Creating A Static "C" Library

We can create a static library using a program called 'ar', for 'archiver'.
To create a static library use the command:

ar rc static_lib.a factorial.o mult.o

This command creates a static library named static_lib.a using two Object file's factorial.o and mult.o,r tells the archiver to replace older object files in the library, with the new object files and c tells the archiver to create the library if it doesn't already exist.

To create an object file form a c file use the command

gcc -g -O -c factorial.c
gcc -g -O -c mult.c

Now we have created the static library we need to index it.
Index is used to by the compiler to speed up symbol-lookup (like functions, variable and so on) inside the library.

The command used to create or update the index is called 'ranlib' and is used like

ranlib static_lib.a

For more info use the commands man ar and man ranlib

#Using A "C" Library In A Program

Up to now we learned about creating a static library and now we want to use this library in our program.

gcc main.c static_lib.a

In this example we will compile the main.c program while requiring the static_lib.a library.

#Creating A Shared "C" Library

shared(Dynamic) library has the same process of creation as static library, but it differs in two ways

When creating the object file for the library we have to use the flags -fPIC or -fpic which are "Position Independent Code"(PIC) to use relative address of the memory, because many different programs may load the program into different location of the memory.

gcc -fPIC -c factorial.c
gcc -fPIC -c mult.c

Unlike static library a shared library is not an archive file,So it has to be specifically tailored to the operating system it is being created. we could use the -G flag or -shared flag depending on the compiler.

gcc -shared shared_lib.so factorial.o mult.o

In this example we use the flag -shared to create the shared library for this library named shared_lib.so using the object files factorial.o and mult.o,By looking at the extension .os we can conclude that this library run on linux.

#Using A Shared "C" Library

As we have mentioned we use the shared library in two cases:

Compile Time - tells the linker to scan the shared library while building the executable program. It's done the same as static library

gcc main.c shared_lib.os

Run Time - tells the loader where to find our shared library. Using the shared library is a little trickier when used in run time. we can use the 'LD_LIBRARY_PATH' environment variable to tell the loader to look in other directories. In bash

LD_LIBRARY_PATH=/full/path/to/library/directory
export LD_LIBRARY_PATH

#Loading A Shared Library Using dlopen()

To load and open a shared(dynamic) library we use the dlopen() function.

Example

#include <dlfcn.h>      /* defines dlopen(), etc.       */

int main(void)
{
void* lib_handle;       /* handle of the opened library */

lib_handle = dlopen("/full/path/to/library", RTLD_LAZY);
if (!lib_handle) {
    fprintf(stderr, "Error during dlopen(): %s\n", dlerror());
    exit(1);
}
}

dlopen() takes two parameters,first one is the full path to shared library and the second one is used to check if the symbols of the library need to be checked immediately(RTLD_LOCAL), or only when used(RTLD_LAZY).

C - Recursion

Haile Melaku — Sun, 09 Oct 2022 09:51:42 +0000

#C - Recursion

Recursion is a method of calling a function inside a function iteratively.

void recursion() {
   recursion(); /* function calls itself */
}

int main() {
   recursion();
}

In this case the function recursion calls a copy of itself to work on a smaller problem until some conditional is satisfied.

Any function which calls itself is called recursive function, and such function calls are called recursive calls.

Recursion is a method of solving problems based on the divide and conquer mentality and we break the problem into much smaller sub part's of itself, one of the subpart consists the a conditional to break the recursion.

Example

Creating a recursive function to find the factorial of a number

Output

C - Even more pointers, arrays and strings

Haile Melaku — Sat, 08 Oct 2022 17:12:31 +0000

Wait we haven't finished pointers yet, if you haven't seen the previous blog post i highly suggest you check it out.
So on this blog post we are going to dive deep into even more pointers.

#C – Pointer to Pointer

Pointer to pointer is a form of chained pointer in which a pointer holds the address of another pointer.

The declaration of pointer to pointer is done by adding an additional asterisk in front of its name.

A pointer with an n amount of asterisk() can hold the address of any pointer with a n - 1 asterisks().

TYPE **VAR_NAME;

In this case the pointer with a double asterisk() can hold the address of a pointer with a single asterisk() and they have the same value across.

Example

Output

To Generalize this Example:
num == *ptr1 == **ptr2
&num == ptr1 == *ptr2
&ptr1 == ptr2

When declaration of variable the memory layout for this example is:

After assigning the value 10 to num the memory layout will look like

After adding in the address of the num to ptr1 and ptr1 to ptr2 the memory layout will look like this:

As you can see in the above tables we used numbers to represent the address of variables to better understand the concept, address are most commonly put in the like the output of the example in some form of hexadecimal.

In the table the value of num = 10 and address = 13, the ptr1 holds the address of num as a value which is 13 and the address of ptr1 is 17.

Now we come to pointer to pointer in the table ptr2 holds the address of the other pointer ptr1 as a value and this is the case of ptr2(double pointer) it holds the address of other pointer in it.

#Two dimensional (2D) arrays

A two dimensional arrays is also know as array of arrays.

To declare a two dimensional array

TYPE ARRAY_NAME[x][Y]

Where type can be any valid C data type, arrayName will be a valid C identifier, x number of rows and y number of columns.

To initializing two-dimensional arrays we use two method

int a[3][4] = {{0, 1, 2, 3},{6, 3, 61, 7},{10, 75, 1, 16}};

int a[3][4] = {0,1,2,3,6,3,61,7,10,75,1,16};

with 2D array, you must always specify the second dimension even if you are specifying elements during the declaration.

int a[][] = {1, 2, 3 ,4 }

This is invalid because the second value is not specified.

Example

Output

The memory layout to the following example is

C - Pointers, arrays and strings

Haile Melaku — Tue, 04 Oct 2022 10:03:01 +0000

Pointer is one of the most confusing concept in c and c++, In this blog post we are going to make it easy to understand this concept.

#Types and memory

When we declare a vaialbe or store any data temporarily the computer will reserve memory for this variable or data and it will store that variable or data in the reserved space in byte.

The example of the memory structure representation we are going to use to understand pointers is

Where the address is just put in numbers to make it easy to understand, normally it is put in hexadecimal, variable is the name and the value is the assigned ascii number attached to the variable.

Depending on the type of a variable the computer will reserve a vary amount of space in memory.

1 byte = 8 bits, each bit being 0 or 1

char = 256 different value = 2^8 = 8 bits = 1 byte
int = 4294967296 different value = 2^32 = 32 bits = 4 byte
float = 4294967296 different value = 2^32 = 32 bits = 4 byte

You can check the size of a variable type using sizeof operator.

Example

When we declare a variable l of type char.

char l;

Int this example we created the address of l is 6.

char l;

l = 'A';

We assigned the value 'A' to the variable l but the byte will not hold a letter 'A', it will hold ascii code, which is 65 (man ascii).

In the int and float case we use 4 bytes.

int n;  

n = 8;

& operator

when we want to find the address of a variable we use the & operator.

Example

The modifier %p is used to print address

#Storing memory addresses

Up to now we learned how to store a character, decimal and floats in a variable.

We also learned how to get the address of variable using & operator.

pointer is simply the address of a piece of data in memory.
pointer variable is a variable that stores the address of that piece of data.

To declare a pointer variable

VARIBALE_TYPE *VARIABLE_NAME

Example

char *p;

A pointer variable holds the address of other variable data
A pointer variable has a size of 8 byte
A pointer variable has his own variable address

Example

int n;
int *p; 

n = 10;
p = &n;

Now the address of n is 3 and the address of n is &n, So we stored the address of n in p pointer variable.
In this example the the address of n is 3,then the value of p is 3 which holds the address of n.

#Dereferencing

Dereferencing is a way of using pointers manipulate values stored at the memory address they point to.

We use the * dereference operator to Dereference the value.

First off * has two functions

used in the declaration. e.g int *p;
used in dereferencing. e.g *p = 20;

Example

int n;
int *p;

n = 11;
p = &n;
*p = 20;

So now:

p == &n holds the address of n
*p == n points the value of n

Now let's break this example using the memory representation.

Up to the part n = 11 and p = &n = 7 the memory representation is

After dereferencing *p = 20 the memory will look like this

#Functions parameters are passed by value

We have covered in the c function blog post that there are two way of passing parameter in functions.

Pass by value: passing the copy of the variable.
Pass by reference: passing the pointer to the variable.

Pass by value: this method only copies the value of the variable in the main function and the change made in the other function doesn't affect the value in the main function because it is just a copy.

Example

Before the execution of i = 20; the memory layout looks like this

After the execution of the i = 20; the memory layout will look like this

When the fun is done executing the variable i is removed and the memory layout looks like this

To modify a variable from outside the function it is declared, using a pointer.

Before the function fun the memory layout looks like this

when we call the function fun the value of p is stored in a new variable called i.

Since i stores the same memory address, it points to the same address, and so both p and i now point to n. Therefore, when we execute the line *i = 20; we modify the value of n and n now holds 20.

When we leave the function fun, the variable i is destroyed, but i’s value is still 20

#Arrays

Arrays in C are contiguous memory areas that hold a number of values of the same type and all elements of an array have the same type.

To declare an array

TYPE ARRAY_NAME[ARRAY_SIZE];

To assign a value
TYPE ARRAY_NAME[ARRAY_SIZE] = {ELEMENTS}

Example

int arr[5];

arr[0] will access the first element, arr[1] the second element, and so on.

In this example the computer will reserve a continuous space for 5 integers in memory.

The memory layout will look like

#Pointers vs Arrays

Arrays are not pointers they don't hold memory address, But the name of an array is the address of the first element of the array.

Example

So why this it outputting the address, when an array a is used in an expression the array type gets automatically implicitly converted to pointer-to-element type(array type decay).

There are two exceptions to this rule in two cases:

sizeof() operator

Example

& operator

Example

#Pointers Arithmetic

We can access the elements of an array using a different method as *(var + x), where var is the name of an array, and x is the (x+1)th element.

Example

The memory is a layout

#Strings

Strings are actually one-dimensional array of characters terminated by a null character '\0'.

TYPE STRING_NAME[SIZE] = {ELEMENT}

Example

You probably notice that we used an array with a size of 6,this is because in C, strings end with the char '\0' (ascii value = 0).

#Memory Layout of C program

Memory layout of C program contains five segments:

stack segment
heap segment
BSS (block started by symbol)
DS (Data Segment)
text segment

Each segment has own read, write and executable permission. If a program tries to access the memory in a way that is not allowed then segmentation fault, which is a common problem that causes programs to crash.

stack

The stack contains local variables from functions, return value and each function has one stack frame.
The stack contains a LIFO(last in first out) structure, Function variables are pushed onto the stack when called and functions variables are popped off the stack when return.

To understand how LIFO work check out the stack data structure.

#include <stdio.h>
int main(void)
{
    int data; //local variable stored in stack
    return 0;
}

Heap

Heap is used to allocate the memory at run time and heap area managed by the memory management functions like malloc, calloc, free, etc

#include <stdio.h>
int main(void)
{
    char *pStr = malloc(sizeof(char)*4); //stored in heap
    return 0;
}

BSS(Uninitialized data segment)

It contains all uninitialized global and static variables.

#include <stdio.h>

int data1; 
// Uninitialized global variable stored in BSS

int main(void)
{
    static int data2;
    // Uninitialized static variable stored in BSS
    return 0;
}

DS(Initialized data segment)

It contains the explicitly initialized global and static variables and this segment can be further classified into an initialized read-only area and an initialized read-write area.

#include <stdio.h>

int data1 = 10 ; 
//Initialized global variable stored in DS
int main(void)
{
    static int data2 = 3;  
    //Initialized static variable stored in DS
    return 0;
}

Text

The text segment contains a binary of the compiled program and he text segment is a read-only segment that prevents a program from being accidentally modified.

#include <stdio.h> 

int main(void) 
{ 
    return 0; 
}

Tip: NULL is for pointers which is the absence of address and '\0' is the is for strings

C - Debugging

Haile Melaku — Mon, 19 Sep 2022 09:01:07 +0000

# What is debugging

A 'bug' is a metaphor for a glitch in your program that might crash or exploit your program on use.

Debugging is the practice of finding and fixing a bug in programs, software, or systems that prevents it from running correctly.

A common practice for debugging is printing data of the program to the console.

The term debugging was first coined by a woman named Admiral Grace Hopper. She found a Moth in the computer's relay which impeded operation. By removing it she said she 'debugged' the system, or something to that effect.

# What are some methods of debugging manually

Rubber Duck Debugging

Rubber Duck Debugging is a way of explaining you code and the process to rubber duck to find and fix a bug in the system.

There are only three simple steps to rubber ducking:

Assume your duck knows absolutely nothing about your problem. State the problem, how things are sitting at the moment, and what you are trying to accomplish instead.
Explain the flow of things. What happened? Go over every single step of the process without missing out on a single detail.
Arrive at a realization of the fix.

Tip: for more info on how to use rubber duck read this article

C - Functions, nested loops

Haile Melaku — Sun, 18 Sep 2022 18:18:27 +0000

Now we are going to see how we use nested loops and function in c.

# C - Nested loops

Nested loop is a way of adding a loop inside a loop and the syntax for a nested loops are:

Nested for loop syntax

for ( initialization; condition; increment ) {

   for ( initialization; condition; increment ) {

      // statement of inside loop
   }

   // statement of outer loop
}

Nested while loop syntax

while(condition) {

   while(condition) {

      // statement of inside loop
   }

   // statement of outer loop
}

Nested do while loop syntax

do{

   do{

      // statement of inside loop
   }while(condition);

   // statement of outer loop
}while(condition);

Example

#include <stdio.h>

/**
 * main - Entry point
 * Description: nested loop
 *
 *Return: Always 0 (Success)
 */

int main(void)
{
       int i,j;

       printf("Nested for loop with @\n");
       for (i = 0;i < 10; i++)
       {
            for(j = 0;j < 10; j++)
            {
                    printf("@");
            }
            printf("\n");
       }
       return (0);
}

output

All the loops have one thing in common, that is once one loop of the outside loop is active then the inner loop starts to activate, the second loop of the outside loop won't be activated until the inner loop finishes.

# C - Functions

A function is a group of statements that are designed to perform a certain task.

Most of the time functions are used to divide up our code into simpler parts that make the code easier to read and debug.

void: is used to indicate that a function don't need a return value.

Syntax

void FUNCTION_NAME( PARAMETER ){}

Functions must be declared before usage.

A function declaration tells the compiler about a function's name, return type, and parameters. A function definition provides the actual body of the function.

Now that we understood the basic concepts of functions let's see the anatomy one by one.

Example: a function that add two numbers, we are going to be using this example all throughout this course.

Function prototype (signature of the function)

Function prototype is used to specify the input/output interface of the function, what to input and what return to expect.

In the example given above the function prototype is
int add(int a, int b)

This prototype is used to:

Specify the return type of the function.e.g on this example we get int value.
Specify the number and data type of the arguments given to the function. e.g this example has 2 argument and both have an int data type.
Specify the name of the function. in the example the function is named add.

automatic variable

This are the variable that are declared inside the function and are only access in the scope of the function.

Example

int add(int a,int b)
{
       int c = 1;
       return (a + b + c);
}

In this example the int c = 1 is an automatic variables and only available in the scope of the function.

Return value

Are the values returned by the function.

Example

return (a + b);

If we don't specify a data type for the return value of the function the compiler will place an int data type by default

add ( int a, int b)
{
  return(a + b);
}

By Default this is an int return type

function invocation

This the calling or usage of the function from the other function statement.

To call a function, you simply need to pass the required parameters along with the function name, and if the function returns a value, then you can store the returned value.

Example

add(5,6)

Forward Declaration

Is the defalcation of a function before or after defining a function by using prototype.

Example

This future of a function is mainly used in Header file and we will be covering it in the next topic.

Function Arguments

Arguments are values that are accepted through the function parameter.

There are two ways in which arguments can be passed to a function:

Call by value: in this case the value passed as an argument is just the copies of the actual values, Making a change to the value in the function doesn't change the argument in the parent function.
Call by reference: in this case the value passed as an argument is the address of the actual values, Making a change to the value in the function affects or changes the argument in the parent function.

Arrays are always going to be called by reference that means they are passed by address.

We will dive deeper into call by reference in the C - pointers.

# C - Header Files

A header file is a file with .h extension which contains C function prototype and macro definitions to be shared between several source files.

Including a header file is like copying the content of the header file.

syntax

For system header files
#include <file.h>

It searches for a file named 'file.h' in a standard list of system directories.

For your own custom header files
#include "file.h"

It searches for a file named 'file.h' in the directory containing the current file

Creating a Header

To create a header file we include this syntax

#ifndef HEADER_FILE_NAME
#define HEADER_FILe_NAME

the entire header file file

#endif

C - Variables, if, else, while

Haile Melaku — Wed, 14 Sep 2022 11:25:03 +0000

We have seen in the past blog about c compilation process, gcc compiler and some basic c language syntax.

Now we are going to see more on variables, if statement, arithmetic operation and while statement.

# Keywords and identifiers

keywords: are predefined function names that has a specific purpose and they cannot be used as identifiers in the program.

Identifiers: c identifiers are names used to refer to a number of things like variable and functions.

Identifiers must start with an alphabetic character.

If you want to be sure that your programs are portable in the new c standard, identifiers need to have a characters limit if 31.

# Arithmetic Operators

Are used to used to perform mathematical operations on the given expressions.

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: print result of arithmetic operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
     int a = 5;
     int b = 15;
     int c;

     c = a + b;
     printf("a + b = %d", c);
     c = a % b;
     printf("a % b = %d", c);

     return (0);
}

# relational operators

Are used to perform comparisons on two variable.

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: print result of arithmetic operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
     int a = 5;
     int b = 15;

     if ( a >= b )
     {
           printf("a is greater than or equal to b");
      }

      return (0);
}

# logical operators

Are used to perform logical operations on the given expressions and there are 3 types of logical operator in c, like logical AND (&&), logical OR (||) and logical NOT (!).

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: print result of arithmetic operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
     int a = 5;
     int b = 15;

     if ( a >= b && a = b)
     {
           printf("both statement's are true");
      }

      return (0);
}

# Bitwise Operators

Are used to perform bit-level operations in C programming.

First you need to revise on how to turn binary into decimal and turn the decimal to binary.

Binary to decimal

Decimal to binary

Bitwise AND Operator &

works like the and logical operator the only case we get true is if 2 values are both true.

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: Bitwise AND Operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
      int a = 8;
      int b = 21;

      printf("a & b = %d",a&b);

      return (0);
}

8 = 00001000 (Binary)
21 = 00010101 (Binary)

Bitwise Operation of 8 and 21

00001000
&00010101
00000000 = 0 (Decimal)

Bitwise OR Operator |

works like the or logical operator the only case we get false is if both values are false.

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: Bitwise OR Operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
      int a = 8;
      int b = 21;

      printf("a | b = %d",a|b);

      return (0);
}

8 = 00001000 (Binary)
21 = 00010101 (Binary)

Bitwise Operation of 8 and 21

00001000
|00010101
00011101 = 29 (Decimal)

Bitwise XOR (exclusive OR) Operator ^

The output is 1(true) if the corresponding bits of two operands are opposite.

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: Bitwise XOR (exclusive OR) Operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
      int a = 8;
      int b = 21;

      printf("a ^ b = %d",a^b);

      return (0);
}

8 = 00001000 (Binary)
21 = 00010101 (Binary)

Bitwise Operation of 8 and 21

00001000
^00010101
00011101 = 29 (Decimal)

Bitwise Complement Operator ~

It changes 1 to 0 and 0 to 1, so complement's in c work differently like the bitwise of 10(-10) which is the 2's compliment instead of 245.

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: Bitwise Complement Operator
 * 
 * Return: Always 0 (Success)
 */

int main() {

    printf("Output = %d\n",~35);
    printf("Output = %d\n",~-12);
    return 0;
}

Right Shift Operator >>

Shift all bit to the right by a specific number

10 = 00001010
10 >> 3 = 00000010
10 >> 0 = 00001010

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: Right Shift Operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
     int i = 10;

     printf("right shift by 3 = %d", i>>3);

     return (0);
}

Left Shift Operator <<

Shift all the bit to the left by a specific number

10 = 00001010
10 << 3 = 00001010000
10 << 0 = 00001010

#include <stdio.h>

/**
 * main - Entry point
 * 
 * Description: Left Shift Operator
 * 
 * Return: Always 0 (Success)
 */

int main(void)
{
     int i = 10;

     printf("left shift by 3 = %d", i<<3);

     return (0);
}

# if, if ... else statements

If statement allows you to control if a program enters a section of code or not based on whether a given condition is true or false.

Syntax

if(boolean_expression 1) {
   /* Executes when the boolean expression 1 is true */
} else if( boolean_expression 2) {
   /* Executes when the boolean expression 2 is true */
} else if( boolean_expression 3) {
   /* Executes when the boolean expression 3 is true */
} else {
   /* executes when the none of the above condition is true */
}

Diagram

Example

#include <stdio.h>

/**
 * main - Entry point
 *
 * Description: if, if ... else statements
 *
 * Return: Always 0 (Success)
 */

int main(void)
{
   int a = 20;

   if( a == 10 ) 
   {
      /* if condition is true then print the following */
      printf("Value of a is 10\n" );
   } 
   else if( a == 20 ) 
   {
      /* if else if condition is true */
      printf("Value of a is 20\n" );
   } 
   else if( a == 30 ) 
   {
      /* if else if condition is true  */
      printf("Value of a is 30\n" );
   } 
   else 
   {
      /* if none of the conditions is true */
      printf("None of the values is matching\n" );
   }

   return (0);
}

# while loop

While loop is used to loop on a statement as long as the given condition is true.

Syntax

while(condition) {
   statement(s);
}

Diagram

Example

#include <stdio.h>

/**
 * main - Entry point
 *
 * Description: while loop statement 
 *
 * Return: Always 0 (Success)
 */

int main(void)
{
     /* local variable definition */
     int a = 0;

     /* while loop execution */
     while( a < 10 ) 
     {
            printf("value of a: %d\n", a);
            a++;
     }

     return (0);
}

C - Hello, World

Haile Melaku — Tue, 13 Sep 2022 14:14:31 +0000

C is a imperative (procedural) language that was created by Dennis Ritchie used to develop software like operating systems, databases, compilers, and so on.

What do we mean when we say imperative (procedural)? We first need to understand different paradigm of programming language and paradigm just means the style in which they are written of structured.

There are different types programming language paradigm, some of them are:

Imperative programming
Procedural programming
Declarative programming
Object-oriented programming

Of these paradigm we just need to know the two of them for c language.

Imperative programming: a set of instructions that are given to the computer to execute in a given order.
Procedural Programming: is a derivation of imperative programming, adding to it the feature of functions (also known as "procedures" or "subroutines").

# Why choose c

A good amount of embedded programming is done in C (Hardware programming)
it fastest language that is high level enough to build practical things.
With the appropriate libraries, you can truly use C for anything.
Web Backend Development.
Desktop App Development.
Game Development.
Language/Compiler Development.
Operating Systems and Drivers.

# Compilation Process

Before we start learning c language we first need to understand the compilation process and the commands used on each process.

The tool we are going to be using in this blog to compile c is gcc tool.

The process of compilation this like this in order:

preprocessor: takes the source code(.c file) to generate intermediate file that is sent to compiler.
Compiler: convert the intermediate code in to assembly code.
Assembler: convert the assembly code in to an object code.
Linker: link the object code with the necessary library to generate the executable file.

Now let's see each one of them individually.

Preprocessor: takes the source file to generate the intermediate file by:

Remove the comments
include header file's code in the file
Replace macro names with code

Source code( .c file)

Now that we created the source code we need to preprocess it and we do that by the command

gcc -E <FILE_NAME>

we can also use the -o function to output into a file.

Compiler: takes the source code to convert it into an assembly code and the command we are going to use is:

gcc -c <FILE_NAME>

Assembler: convert the assembly code into binary code 0's and 1's or machine code and the command we are going to use is:

gcc -S <FILE_NAME>

Linker: linker's includes some of the library files into the program to create an executable file and the command we are going to use is:

gcc <FILE_NAME>

Now that we learned about the compilation process, we need to understand the gcc compiler.

gcc

GCC (GNU Compiler Collections) is a compiler mainly used for C and C++ language.

-o : is an option to specify the output of the file.

-Werror: is an option to show the warning if any error is there in the program.

-Wall: is an option to show all kind of warning like unused variables errors.

-std=: is an option to set the standard(version) of c to compile source file.

Tip : For more information on gcc compiler use the command man gcc to read the manual.

#C - Hello, world

Now we finished learning about compilation process and gcc compiler, we need to get our hand dirty and start codding in c.

The first thing we need to do is learn the most common style of writing c language and how to document them,For this course we need to use the Linux kernel coding style Linux style.

Hello world code

The structure of a hello world code

#include <stdio.h> is the header file that define the input output routines used by a program.

int main(void) is the entry point of our program
printf("Hello world") is a line that print the text

Comments

used to document you code and some of c language commenting syntax are:

/* comment  */

/*
 * muti line
 * commnet
 */

Warning: you can not nest a comment in a comment

Variables

Used to connect a value to a symbol

<type> <var_name>

Names of variables: [a-zA-z_][a-zA-Z_0-9]*

int var;
char c;

Data types

Tip: for more info on data type read Data Type

Modifiers

some of the modifiers used in c are long, long long,short,unsigned and signed.

They are used to specify how much space the variable take on memory.

long, long long : are used to extend the space used on the system and can be used with int, double.
short: takes half the space on the system.
signed: support both positive and negative numbers, we can use it with int, char.
unsigned: support only positive numbers, we can use it with int,char.

sizeof()

This function is used to find out how a much size types use.

sizeof(char);

Type casting

Is a way of converting one type of data into another.

Example:

char c = 'a';
int i = 5;

int_num = (int)c;
float_num = (float)i;

we essentially converted the char into int and the int into float.

pritnf()

Used for printing or writing a statement on to the stdout.

printf("hello world")

printf("string:%s deciaml:%d float:%f char:%c","name",12,2.6,'C');

special symbols like %s,%d and %f are used to represent different data's that are imputed to the right of the main string.

puts

Does not include null character inputs to write or print to stdout.

puts("hello world");

putchar

Used to write a character, of unsigned char type, to stdout.

char i = 'a';

putchar(i);

putchar can sometimes be used to print digit's,To do this we need using ASCII value of '0'.

int i = 10;

putchar(i + '0');

Shell, init files, variables and expansions

Haile Melaku — Thu, 08 Sep 2022 06:41:04 +0000

So, today am going to be checking more about shell, more specifically topics on Shell initialization files,variables and shell expansions.

#Shell initialization files

When a shell is opened, there are certain initialization/startup files that are read which help to setup an environment for the shell itself and the system user.

Before we get into shell initialization we need to understand the three mods of the shell when it is opened:

Interactive login
Interactive non-login
non-interactive non-login shell
non-interactive login shell

Now let's see each one in more detail

Login shell: executes under our user ID when we log in to a session.
Interactive shell: Reads commands from user input on a terminal.

Interactive Login

In this mode you login in a remote computer.

for example it can be run through:

using ssh

Interactive non-login

In this mode you just open a terminal.

for example it can be run through:

running /bin/bash
running /bin/su

non-interactive non-login shell

In this mode you run a script, it only opens to execute the script and closes immediately once the script is finished.

non-interactive login shell

In this mode you run a script remotely vi ssh or telnet.

for example :
echo command | ssh server

Now that we understood the concepts of intractability and login ,we need to see the two types of shell initialization files

system-wide startup files
user-specific startup files

system-wide startup files: are global configuration that apply to all users in the system and are located in the /etc directory.

Some of them are :

- /etc/profiles: it stores system-wide environment configurations and startup programs for login setup.

On some systems this file holds pointers to other configuration files such as:

/etc/inputrc: to configure the command line bell-style.
/etc/profile.d directory: contain system-wide behavior of specific program configuration

- /etc/bashrc or /etc/bash.bashrc: it stores system-wide functions and aliases including other configurations that apply to all system users.

wuser-specific startup files: are store configurations that apply to a single user on the system and located in the users home directory as dot files.

Some of them in there process are :

.bash_profile : stores user specific environment and startup programs configurations.
.bashrc : Stores user-specific aliases and functions
.bash_login : Contains specific configurations that are normally only executed when you log in to the system. When the ~/.bash_profile is absent, this file will be read by bash
.profiles : In the absence of ~/.bash_profile and ~/.bash_login, ~/.profile is read. It can hold the same configurations, which are then also accessible by other shells.
.bash_history : Bash maintains a history of commands that have been entered by a user on the system. This list of commands is kept in a user’s home directory in the ~/.bash_history file.
.bash_logout : it’s not used for shell startup, but stores user specific instructions for the logout procedure. It is read and executed when a user exits from an interactive login shell.

Tip: to see the login process use this Video

Tip: for more info on this info

#Variables

A variable is an abstract storage location paired with an associated symbolic name.

A shell variable is a variable that is available only to the current shell.

An environment variable is available system wide and can be used by other applications on the system.

Bash keeps a list of two types of variables:

Global variables
Local variables

Global variables: are variables that are available to all Bash scripts on your system, we use the commands env or printenv to display environment variables.

Local variables: are variables that can only be used within the script (or shell) in which they're defined..

To create a shell variable we use the following command

NAME='VALUE'

export : we can use the export command to export variables to the child-processes.

to view all the exported variables ,we use the command

export -p

And to export the variables, we use the command

export NAME='VALUE'

Reserved variable are set or used by Bash, but other shells do not normally treat them specially.

Some examples of reserved variable are:

HOME : The current user's home directory; the default for the cd built-in. The value of this variable is also used by tilde expansion.

PATH : A colon-separated list of directories in which the shell looks for commands.

PS1 : The primary prompt string. The default value is "'\s-\v\$ '".

#Expansion

Expansion is the process of Performed upon the text before it carries out our command.

There are many kinds of Expansions performed, some of them are:

Pathname Expansion: is mechanism by which wildcards work.

Tilde(~) Expansion: When used at the beginning of a word, it expands into the home directory of the current user.

Arithmetic Expansion: a mechanism to perform arithmetic on the shell.
$((expression))

To see all arithmetic expansion read this Docum

Brace Expansion: We use the expression in the brace to generate multiple text strings.

Parameter Expansion: the use of variables to expand.

This are some of the expansions used Linux

Command Substitution: is able to output a command as an expansion.

Tip: for more info on expansion read article

alias

alias is a linux command used to create custom made linux commands.

alias [alias-name[=string]...]

Tip: for more info on alias read alias or use the command man alias

Shell, I/O Redirections and filters

Haile Melaku — Tue, 06 Sep 2022 09:56:03 +0000

Today we are going to touch on some more Linux shell topics such as i/o stream, filters and pips.

#I/O Redirection

I/O redirection is the redirecting of input and output of many commands to files, devices, and even to the input of other commands.

Streams

Input and output in the Linux environment is distributed across three streams:

standard input (stdin) (0)
standard output (stdout) (1)
standard error (stderr) (2)

Standard Input

The standard input moves data form user or keyboard to program.
To do this we use the notation for the input standard, < and << have different functionality one has:

Overwrite

< - standard input

Append

<< - standard input

Standard Output

The standard output is the output generated by a program, it will output text directly to the terminal or a file.
To do this we use the notation for the output standard, > and >> have different functionality one has:

Overwrite

> - standard output

Append

>> - standard output

Standard Error

The standard error is s errors generated by a program that has failed in some way.
To do this we use the notation for the error standard, 2> and 2>> have different functionality one has:

Overwrite

2> - standard error

Append

2>> - standard error

Tip: for more info read i/o redirect

#Pipelines

Pipes are used to redirect a stream from one program to another and it connects multiple commands together.

What that mean is pips work like an assembly line in factory once one program runs and outputs then that output is moved through the pip to the second command.

We declare a pip using this command
|

What this command do is it takes the output of ls -la then display it using less.

#Filters

Filters are mostly used with pips.Filters take standard input and perform an operation upon it and send the results to standard output.

Here are some of the common programs that can act as filters:

find - returns files with filenames that match the argument passed to find.
grep - returns text that matches the string pattern passed to grep.
tr - finds-and-replaces one string with another.
wc - counts characters, lines, and words.

#Commands

Now that we seen these concepts we need to see some common Linux commands and programs we will be using in this topic.

echo

we use the command echo display a line of text and to write into a file using i/o streams.

echo [SHORT-OPTION]... [STRING]...

We use with the stream

We need special characters to string char

Tip: for more info use the command man echo

cat

we use the command cat to concatenate files and print on the standard output.

cat [OPTION]... [FILE]...

head

we use the command head to output the first part of files.

head [OPTION]... [FILE]...

tail

we use the command tail to output the last part of files.

tail [OPTION]... [FILE]...

find

we use the command find to search for files in a directory hierarchy.

find [-H] [-L] [-P] [-D debugopts] [-Olevel] [starting-point...] [expression]

wc

we use the command to print newline, word, and byte counts for each file.

wc [OPTION]... [FILE]...

sort

we use the command to sort lines of text files.

sort [OPTION]... [FILE]...

uniq

we use the command to report or omit repeated lines.

uniq [OPTION]... [INPUT [OUTPUT]]

grep

we use the command to print lines that match patterns.

grep [OPTION...] PATTERNS [FILE...]

tr

we use the command to translate or delete characters.

tr [OPTION]... SET1 [SET2]

rev

we use the command to reverse lines characterwise.

rev [option] [file...]

cut

we use the command to remove sections from each line of files.

cut OPTION... [FILE]...