DEV Community: Clifford Mapesa

What are argc and argv?

Clifford Mapesa — Mon, 27 Nov 2023 06:47:12 +0000

Introduction

Imagine you want to run a program that accepts command-line arguments. Let's consider a program like gcc. To compile an object file named progam we type the following to the command line:

gcc my_program.c -o my_program

The character my_program.c ,-o, my_program are all arguments to the gcc command. (gcc is an argument as well, as we shall see)

Command line arguments in C are very useful. They give a function the ability to pass arguments from the command line. All arguments you pass to the command line end up as arguments to the main function in your program.

Syntax

The main function that accepts command line arguments is written like this:

#include <stdio.h>

int main(int argc, char argv[])
{
    return (0);
}

argc - Stands for "argument count". It represents the count of arguments supplied to the program.

argv - Stands for "argument vector". A vector is a one-dimensional array and argv is a one-dimensional array of strings.

In some functions the argv is declared like this:

#include <stdio.h>

int main(int argc, char **argv)
{
    return (0);
}

The name of an array is converted to the address of its first arguments. Both declarations are similar in this context.

Usage

Let's look at this example:

gcc my_program.c -o my_program

This would result in the following values:

argc: 4
argv[0]: gcc
argv[1]: my_program.c
argv[2]: -o
argv[3]: my_program

As you can see, the first argument (argv[0]) is the name by which the program was called, in this case gcc. Thus, there will always be at least one argument to a program, and argc will always be at least 1.

Example

#include <stdio.h>

/**
 * main - Entry point.
 * @argc: Argument count
 * @argv: Argument vector
 *
 * Return: 0 (Success)
 */
int main(int argc, char *argv[])
{
    printf("Argument count (argc): %d\n", argc); 

    /*Print each command-line argument */
     for (int i = 0; i < argc; i++) 
     { 
         printf("Argument %d: %s\n", i, argv[i]); 
     }
    return (0);
}

If you compile and run this program with the command ./program arg1 arg2 arg3, the output will be:

Argument count (argc): 4 
Argument 0: ./program 
Argument 1: arg1 
Argument 2: arg2 
Argument 3: arg3

Conclusion

In summary, argc and argv are essential for building flexible and versatile C programs that can adapt their behavior based on command-line inputs.

Happy hacking!

Getting Started With Static Libraries In C

Clifford Mapesa — Wed, 22 Nov 2023 09:21:48 +0000

Introduction

To understand how static libraries work let's first look at the compilation process of a file in C programming. Compilation is when code is transformed from human-readable language to machine language. The software that is used for this conversion is known as a Compiler, e.g. gcc.

The C compilation follows these stages:

1. Preprocessing

This is the first stage where the source code is passed. The source code is made ready for compilation. The source code is expanded (adds the required information) and then this expanded source code is passed on to the compiler.

2. Compilation

Once preprocessing is complete, the actual compilation begins. The compiler takes the C code and translates it into assembly code, specific to the target platform. Assembly code represents a low-level view of the program, consisting of instructions that the processor can execute. The source file which got the ( .i ) extension in the previous step gets converted into ( .s ) extension by the compiler.

3. Assembly

Next, the assembler converts the assembly code into machine code, also known as object code. The object code consists of binary representations of instructions and data. This step is a crucial bridge between human-readable code and the language the computer understands. -The extension of the file in this step becomes ( .obj ).

4. Linking

A linker is a tool that is used to link all the parts of a program together in order of execution. The Linker plays a very important role. If your C program includes a header file, and you are using some function defined in that header file, then the Linker will ink the required object code for the function in the library, to the object code of your program and package them together.

Note: To remember the compilation process use PCAL mnemonic.

Figure: Compilation process of a C program

A library is a file containing several object files that can be used as a single entity in the linking phase of a program. A static library is a collection of object files that are linked into the program during the linking phase of compilation, and are not relevant during runtime.

How to create a static library

Step 1

The first step is to compile our code using a compiler e.g. gcc:

gcc -c *.c

gcc is the compiler
The -c flag informs gcc to compile our C files without the linking phase
The argument .c* tells gcc to compile ALL files whose names end with .c extension

Step 2

The next step is to use a program called ar for "archiver" to create a static library. This program can be used to create static libraries, modify object files in the static library, list the names of object files in the library, and so on. In order to create a static library, we can use a command like this:

ar -rc libexample.a *.o

* ar is the name of a program that creates static libraries.

The r flag tells it to insert files into the archive, if a file with the same name exists it will be replaced.
The c flag tells ar to create the library if it doesn't already exist. If it does exist, the command will proceed, replacing existing files with new ones.
libexample.a is the name of the library. The prefix " lib" is the naming convention. The .a extension is commonly used for static libraries in Unix-like systems.
.o this matches all files with the extension .o in the current directory. These are the object files that will be added to the archive. Object files are typically the result of compiling source code files.

Step 3

After an archive is created, or modified, there is a need to index it. This index is later used by the compiler to speed up symbol lookup inside the library, and to make sure that the order of the symbols in the library won't matter during compilation (this will be better understood when we take a deeper look at the link process at the end of this tutorial). The command used to create or update the index is called 'ranlib', and is invoked as follows:

ranlib libexample.a

If we want to see object files present in our static library we use the following command:

ar -t libexample.a

ar: This is the archive command in Unix-like operating systems.
-t: This option stands for "table of contents." It is used to display the names of the files (object files) contained in the archive without extracting them.
libexample.a: This is the name of the static library for which you want to view the table of contents.

We can also see the symbols and associated information in our library, using the command nm

nm libexample.a

How to use a C Library in a program

When compiling your main program, specify the static library using the -l flag (for library) and provide the library name (without the "lib" prefix and ".a" extension). For example:

gcc main.o -o my_program -L. -lexample

main.o: Your main program's object file.
-o my_program: Specifies the output executable name.
-L.: Instructs the linker to look for libraries in the current directory.
-lexample: Links with the libexample.a static library.

How to run our program

The command we can use, after all these steps, is:

`
./my_program

Advantages and Disadvantages

Advantages

Simplicity: Easy to use an deploy
Performance: Generally faster execution since everything is resolved at compile time
Independence: No external dependencies during runtime

Disadvantages

Size: Can lead to larger executables
Updates: Requires recompilation if the library is modified.
Shared Memory: Multiple instances of a program share the same code in memory

When to use static libraries

When performance is critical and the size of the executable is not a significant concern
Suitable for small to medium-sized projects, where simplicity and independence are valued.

Conclusion

In summary, static libraries are a powerful tool for code organization, reuse, and distribution. They simplify the process of including external code in your projects and provide a way to create standalone executables. However, developers need to consider trade-offs, such as larger executables and the need for recompilation when making changes to the library.

References

Introduction To Open Source Vocabulary

Clifford Mapesa — Sat, 18 Nov 2023 08:13:37 +0000

What is open source software?

Open source software (OSS) is software whose source code is made available to the public. In this way, it is available for use, modification, and distribution with its own rights. Source code is part of the software that most users don't see, it's code that programmers manipulate to control how a program or application behaves. Programmers with access to source code can change a program by adding to it, changing it, or fixing sections of it that arent working properly. OSS includes a license that permits programmers to modify a piece of software to best fit their needs or user's needs and control how the software can be distributed.

Open source vocabulary

To be able to delve into the world of open source and in the process have a smooth transition it is imperative for one to know the vocabulary used. Here are some of the terms used in open source:

Repository: It is a collection of files and folders associated with a project, along with each file's revision history. Mostly managed by version control.
Collaborators/Contributors: These are people who take part in the contribution process. It can be through code, documentation, reviews, etc.
Commit: A commit indicates changes made to files and folders in a repository. It provides a history of changes made.
Forking: It is making a copy of a repository from one user's account when you don't have write access to it. So you can just copy it and modify it under your own account.
Pull request: When you have made changes and you want to update the changes to the original repository you make a pull request.
Merge: It is when the owner of the original accepts the changes you've made and updates the changes to the original repository. If your pull request is accepted by the owner then you get its credit on the original site and shows up in your user profile
Branch: When you want to make changes to a repository you create a branch and then check it out.
Maintainers: They are in charge of making decisions, code reviews, and supervising the project.
Code review: Acts as quality assurance of a code base. Help in identifying bugs, increase code quality, and help developers understand/ or learn the source code.
Issues: Mostly used in reporting bugs and requesting features. Sometimes it hosts discussions, helps process support requests, or even submits documentation feedback.
README.md : It serves as the face of the project. It introduces and explains a project by providing a detailed description of the project.
CONTRIBUTING.md : A CONTRIBUTING.md file, in an open source repository or site, provides potential project contributors with a short guide to how they can help with the project.
CODE-OF-CONDUCT: It is a document that establishes expectations for behavior for a project's participant. Defines standards for how to engage in a community

Conclusion

Open source contribution is an opportunity to learn new skills, connect with other contributors, and make a positive impact.

Happy coding!