To compile and run a C program on Linux, you must first ensure the GCC compiler is installed via your distribution's package manager. Then, write your source code in a file with a
.c extension, such as
hello.c. Finally, execute the command
gcc hello.c -o hello to generate an executable binary named
hello, which can be launched by typing
./hello in the terminal. This workflow transforms human-readable text into machine-executable instructions that the operating system can process directly.
Verifying GCC Installation
Before attempting to compile any code, it is essential to confirm that the GNU Compiler Collection (GCC) is present on your system. Most modern Linux distributions do not include development tools by default to save space and reduce security surface area. If you attempt to run
gcc without it installed, the terminal will return a "command not found" error.
You can check for the presence of GCC by running the following command in your terminal:
gcc --version
If the compiler is installed, this command will output version information, including the GCC version number and the copyright details. If the command fails, you need to install the build tools appropriate for your distribution. For Debian-based systems like Ubuntu, use:
sudo apt update && sudo apt install build-essential
For Red Hat-based systems like Fedora or CentOS, the equivalent command is:
sudo dnf groupinstall "Development Tools"
On Arch Linux, you can install the base-devel package which includes GCC:
sudo pacman -S gcc
Installing the full development toolkit ensures that you have not only the compiler but also essential utilities like make and standard libraries required for more complex projects later on.
Writing Your First C Program
Create a new file to hold your source code. While you can use any text editor, simple editors like
nano,
vim, or
gedit are sufficient for beginners. Create a file named
hello.c. The
.c extension is critical because it signals to the compiler that the file contains C source code.
Open the file and enter the following standard boilerplate code:
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
This code performs three distinct actions. First,
#include <stdio.h> tells the preprocessor to include the Standard Input Output header file, which defines the function
printf. Without this line, the compiler would not recognize
printf and would throw an error. Second, the
main function serves as the entry point for every C program. The operating system calls this function when you execute the binary. Third,
printf outputs the string "Hello, World!" followed by a newline character (
\n) to the terminal. The function returns
0 to indicate successful execution to the shell.
Save the file after making these changes. You can verify the content using the
cat command:
cat hello.c
Compiling the Source Code
Compilation is the process of translating high-level C code into low-level machine code that the CPU can understand. This step involves two phases: compilation and linking. During compilation, the source code is translated into object code. During linking, necessary library functions are resolved and combined with your object code to create a standalone executable.
Navigate to the directory containing
hello.c in your terminal. Run the following command:
gcc hello.c -o hello
The
gcc command invokes the compiler. The argument
hello.c specifies the input source file. The flag
-o stands for "output," allowing you to specify the name of the resulting executable. In this case, we named it
hello. If you omit the
-o flag, GCC defaults to creating an executable named
a.out, which is less descriptive and harder to manage in larger projects.
If the compilation is successful, the command prompt will return silently. If there are syntax errors, missing headers, or type mismatches, GCC will print error messages indicating the line number and nature of the problem. Fix these errors in your text editor and re-run the compilation command until no errors appear.
Running the Executable
Once the binary is created, you can execute it just like any other command-line tool. However, for security reasons, Linux does not search the current directory for executables by default. You must explicitly tell the shell where to find the program.
Run the following command:
./hello
The
./ prefix means "the current directory." It instructs the shell to look for an executable file named
hello in the folder you are currently in. Upon execution, the terminal should display:
Hello, World!
If you receive a "Permission denied" error, it means the file lacks execute permissions. You can fix this by running:
chmod +x hello
This adds the execute bit to the file's permissions, allowing it to be run. After applying this change, try running
./hello again.
Understanding this basic workflow is fundamental to software development on Linux. As your projects grow in complexity, you will likely move from single-file compilations to multi-file projects managed by Makefiles or CMake. However, the core principle remains the same: source code is written, compiled into objects, linked into binaries, and then executed. For those interested in related system administration tasks, such as fixing package management errors that might interfere with installing compilers, see our guide on
Fixing E: Sub-process /usr/bin/dpkg returned an error code (1) on Kali Linux. Additionally, if you are working with network streams rather than local binaries, you might find
How to detect with ffmpeg if the stream has video or audio or both useful for handling multimedia data.
Frequently Asked Questions
Why did I get a 'command not found' error when typing gcc?
This error indicates that GCC is not installed on your system or is not in your system's PATH. You need to install the build-essential package or the equivalent development tools for your specific Linux distribution before you can compile C programs.
What is the difference between compiling and linking?
Compiling converts your source code (.c files) into object code (.o files), while linking combines these object files with library code to resolve function references and create a final executable binary. Modern GCC handles both steps automatically in a single command unless you explicitly separate them.
Can I name my executable something other than 'hello'?
Yes, you can name your executable anything you like by changing the argument after the
-o flag. For example,
gcc hello.c -o myprogram will create an executable named
myprogram. Just remember to run it using
./myprogram in the terminal.
Why do I need the #include <stdio.h> directive?
This directive includes the Standard Input Output header file, which provides the declarations for functions like
printf and
scanf. Without it, the compiler does not know what these functions are, leading to implicit declaration warnings or errors during compilation.
What does the return 0 statement in main() do?
The
return 0 statement sends an exit status code back to the operating system. A return value of zero conventionally indicates that the program terminated successfully. Non-zero values typically signal errors, which can be checked by scripts or other programs using the
$? variable in bash.