{"id":6603,"date":"2024-01-02T10:30:10","date_gmt":"2024-01-02T17:30:10","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=6603"},"modified":"2024-01-02T10:30:49","modified_gmt":"2024-01-02T17:30:49","slug":"install-gcc-command-linux","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/install-gcc-command-linux\/","title":{"rendered":"Installing and Using the GCC Command: Linux User Guide"},"content":{"rendered":"
\n
\"Illustration<\/figure>\n<\/div>\n

Are you planning to compile your C programs in Linux? You might find the task daunting, especially if you’re a beginner. However, the ‘GCC’ command, akin to a skilled translator, converts your C code into an executable program. It’s a tool that’s worth learning to install and use. GCC is readily available on most package management systems, making the installation process fairly straightforward.<\/p>\n

In this guide, we will navigate you through the process of installing and using the GCC command in Linux.<\/strong> We will provide you with instructions for both APT and YUM-based distributions, delve into compiling GCC from source, installing a specific version, and finally, how to use the GCC command and ensure it’s installed correctly.<\/p>\n

So, let’s dive in and start installing GCC on your Linux system!<\/p>\n

TL;DR: How Do I Install and Use the GCC Command in Linux?<\/h2>\n

\n In most Linux distributions, the GCC command comes pre-installed. However, if it’s not, you can install it in Debian based distributions like Ubuntu, by running the command sudo apt-get install gcc<\/code>. For RPM-based distributions like CentOS, you would run the command sudo yum install gcc<\/code>.\n<\/p><\/blockquote>\n

# For Debian based distributions like Ubuntu\nsudo apt-get install gcc\n\n# For RPM-based distributions like CentOS\nsudo yum install gcc\n\n# Output:\n# 'gcc is already the newest version (4:7.4.0-1ubuntu2.3).'\n# OR\n# 'Package gcc is not available, but is referred to by another package...'\n<\/code><\/pre>\n
This is just a basic way to install the GCC command in Linux, but there’s much more to learn about installing and using GCC. Continue reading for more detailed information and advanced usage scenarios.<\/p>\n
Getting Started with GCC Command in Linux<\/h2>\n
If you’re new to Linux or programming, you might be wondering what GCC is. GCC, short for GNU Compiler Collection, is a compiler system that supports various programming languages, including C, C++, Objective-C, Fortran, Ada, and more. It’s an essential tool for developers as it translates your source code into an executable program that your machine can understand.<\/p>\n
Installing GCC with APT<\/h3>\n
If you’re using a Debian-based distribution like Ubuntu, you’ll likely be using the APT package manager. Here’s how you can install GCC:<\/p>\n
sudo apt update\nsudo apt upgrade\nsudo apt install build-essential\n\n# Output:\n# 'Reading package lists... Done'\n# 'Building dependency tree'\n# 'Reading state information... Done'\n# 'gcc is already the newest version (4:7.4.0-1ubuntu2.3).'\n# OR\n# 'Setting up gcc (4:7.4.0-1ubuntu2.3) ...'\n<\/code><\/pre>\n
In this code block, we first update the package list and upgrade the system. Then, we install build-essential<\/code> which includes GCC and other necessary packages for building software.<\/p>\n
Installing GCC with YUM<\/h3>\n
For RPM-based distributions like CentOS, the YUM package manager is commonly used. Here’s how you can install GCC with YUM:<\/p>\n
sudo yum check-update\nsudo yum upgrade\nsudo yum install gcc\n\n# Output:\n# 'Loaded plugins: fastestmirror'\n# 'Loading mirror speeds from cached hostfile'\n# 'Package gcc is not available, but is referred to by another package...'\n# OR\n# 'Installed: gcc.x86_64 0:4.8.5-44.el7'\n<\/code><\/pre>\n
Here, we’re doing something similar to the APT commands: updating the package list, upgrading the system, and then installing GCC.<\/p>\n
Now, you have GCC installed on your Linux system and you’re ready to compile your C programs!<\/p>\n
Installing GCC from Source Code<\/h2>\n
If you need a specific version of GCC or want to customize the build, you might prefer to install GCC from source code. Here’s a basic example of how you might do this:<\/p>\n
# Download the source code\nwget http:\/\/ftp.gnu.org\/gnu\/gcc\/gcc-9.2.0\/gcc-9.2.0.tar.gz\n\n# Extract the tarball\ntar xf gcc-9.2.0.tar.gz\n\n# Navigate into the directory\ncd gcc-9.2.0\n\n# Configure the build\n.\/configure --disable-multilib --enable-languages=c,c++\n\n# Build and install\nmake -j$(nproc)\nsudo make install\n\n# Output:\n# 'gcc-9.2.0.tar.gz 100%[===================>] 104.50M  1.94MB\/s    in 54s'\n# 'gcc-9.2.0\/configure: creating .\/config.status'\n# 'gcc-9.2.0\/configure: creating .\/config.status'\n<\/code><\/pre>\n
This will download the GCC 9.2.0 source code, configure the build, and then compile and install GCC. The --disable-multilib<\/code> flag is used to only support 64-bit software, and --enable-languages=c,c++<\/code> is used to only build the C and C++ compilers.<\/p>\n
Installing Different Versions of GCC<\/h2>\n
Different versions of GCC have different features and support for different language standards. You might need a specific version of GCC for a certain codebase. Here’s how you can install different versions of GCC from source and using package managers.<\/p>\n
Installing Different Versions from Source<\/h3>\n
You can replace gcc-9.2.0<\/code> in the previous example with the version you need. The GCC mirrors page lists all available versions.<\/p>\n
Installing Different Versions with APT<\/h3>\n
On Debian-based distributions, you can install a specific GCC version with the apt<\/code> package manager:<\/p>\n
sudo apt install gcc-8\n\n# Output:\n# 'Reading package lists... Done'\n# 'Building dependency tree'\n# 'Reading state information... Done'\n# 'gcc-8 is already the newest version (4:7.4.0-1ubuntu2.3).'\n<\/code><\/pre>\n
Installing Different Versions with YUM<\/h3>\n
On RPM-based distributions, you can use the yum<\/code> package manager to install a specific GCC version:<\/p>\n
sudo yum install gcc48\n\n# Output:\n# 'Loaded plugins: fastestmirror'\n# 'Loading mirror speeds from cached hostfile'\n# 'Package gcc48 is not available, but is referred to by another package...'\n<\/code><\/pre>\n
Here’s a summary of the key changes in the last few GCC versions:<\/p>\n\n\n\n\n\n\n\n\n
Version<\/th>\nKey Changes<\/th>\n<\/tr>\n<\/thead>\n
GCC 7<\/td>\nFull C++14 support, initial C++17 support<\/td>\n<\/tr>\n
GCC 8<\/td>\nFull C++17 support, initial C++2a support<\/td>\n<\/tr>\n
GCC 9<\/td>\nFull C++2a support, new optimizations<\/td>\n<\/tr>\n
GCC 10<\/td>\nNew features and optimizations, initial C++20 support<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Using and Verifying GCC Installation<\/h2>\n
You can compile a C program with GCC using the following command:<\/p>\n
gcc hello.c -o hello\n\n# Output:\n# 'hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter \/lib64\/ld-linux-x86-64.so.2, for GNU\/Linux 3.2.0, BuildID[sha1]=5c9f85a8aa9bfa58c86e64e0d10aa8afb4a1c5e8, not stripped'\n<\/code><\/pre>\n
This will compile the hello.c<\/code> file into an executable named hello<\/code>. You can run it with .\/hello<\/code>.<\/p>\n
You can verify your GCC installation and version with the following command:<\/p>\n
gcc --version\n\n# Output:\n# 'gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0'\n<\/code><\/pre>\n
This will print the GCC version, which can be useful for troubleshooting or verifying that you have the correct version installed.<\/p>\n
Exploring Alternatives to GCC<\/h2>\n
While GCC is a popular choice for compiling C programs, it’s not the only option. There are other compilers and techniques you can use to accomplish the same task. Let’s explore some of these alternatives, their benefits, drawbacks, and situations where they might be a better choice.<\/p>\n
Clang: A Modern Compiler<\/h3>\n
Clang is a compiler front end for the C, C++, and Objective-C programming languages. It uses LLVM as its back end and has been part of the LLVM release cycle since LLVM 2.6.<\/p>\n
It’s known for providing expressive diagnostics, a modular library-based architecture, and strong adherence to standards.<\/p>\n
You can install Clang on Ubuntu like this:<\/p>\n
sudo apt-get install clang\n\n# Output:\n# 'Reading package lists... Done'\n# 'Building dependency tree'\n# 'Reading state information... Done'\n# 'clang is already the newest version (1:6.0-41~exp5~ubuntu1).'\n<\/code><\/pre>\n
And here’s how you compile a program:<\/p>\n
clang hello.c -o hello\n\n# Output:\n# 'hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter \/lib64\/ld-linux-x86-64.so.2, for GNU\/Linux 3.2.0, BuildID[sha1]=5c9f85a8aa9bfa58c86e64e0d10aa8afb4a1c5e8, not stripped'\n<\/code><\/pre>\n
Intel C++ Compiler<\/h3>\n
The Intel C++ Compiler, also known as icc, is a group of C and C++ compilers from Intel. If you’re developing software specifically for Intel hardware, you might find icc more suitable.<\/p>\n
TinyCC<\/h3>\n
If you’re working on a project where binary size matters more than speed, TinyCC (tcc) might be worth considering. As the name suggests, it’s a very lightweight C compiler, but it’s not as fast or fully-featured as GCC.<\/p>\n
Using Makefiles<\/h3>\n
Makefiles can simplify the build process, especially for larger projects. They let you specify how to derive the executable from source files without having to list all the commands every time.<\/p>\n
Here’s a basic Makefile for a C program:<\/p>\n
# Makefile\n\nhello: hello.c\n    gcc -o hello hello.c\n\n# Output:\n# 'gcc -o hello hello.c'\n<\/code><\/pre>\n
You can then compile the program with just make<\/code>.<\/p>\n
Using IDEs<\/h3>\n
Integrated Development Environments (IDEs) like Eclipse, NetBeans, and CLion can manage the build process for you. They often include features like automatic build configuration, a graphical debugger, and integrated version control.<\/p>\n
Remember, the best tool depends on your specific needs. GCC is a great general-purpose compiler, but there are situations where alternatives might be more suitable. By understanding these alternatives, you can make a more informed decision and choose the best tool for your needs.<\/p>\n
Navigating Common GCC Errors<\/h2>\n
While GCC is a powerful tool, you might encounter some errors or obstacles along the way. Here are some common issues and how to resolve them.<\/p>\n
‘gcc: Command not found’<\/h3>\n
If you see this error, it means that GCC is not installed or not available in your PATH.<\/p>\n
gcc --version\n\n# Output:\n# 'bash: gcc: command not found'\n<\/code><\/pre>\n
To resolve this, you can install GCC using the methods we discussed earlier. If GCC is installed but not in your PATH, you’ll need to add it. This process varies depending on your shell and system configuration.<\/p>\n
‘fatal error: stdio.h: No such file or directory’<\/h3>\n
This error occurs when GCC can’t find the stdio.h<\/code> header file, which is part of the standard library. Here’s what the error might look like:<\/p>\n
gcc hello.c -o hello\n\n# Output:\n# 'hello.c:1:10: fatal error: stdio.h: No such file or directory'\n# ' #include '\n# '          ^~~~~~~~~'\n# 'compilation terminated.'\n<\/code><\/pre>\n
To fix this, you need to install the standard library development files. On Debian-based distributions, you can do this with sudo apt install libc6-dev<\/code>. On RPM-based distributions, you can use sudo yum install glibc-devel<\/code>.<\/p>\n
‘undefined reference to `main’<\/h3>\n
This error occurs when GCC can’t find the main<\/code> function. In C, every program must have a main<\/code> function as the entry point.<\/p>\n
gcc hello.c -o hello\n\n# Output:\n# '\/usr\/lib\/gcc\/x86_64-linux-gnu\/7\/..\/..\/..\/x86_64-linux-gnu\/Scrt1.o: In function `_start':\n# '(.text+0x20): undefined reference to `main'\n# 'collect2: error: ld returned 1 exit status'\n<\/code><\/pre>\n
To resolve this, make sure your program has a main<\/code> function. If it’s intended to be a library, you should compile it with -c<\/code> to produce an object file.<\/p>\n
Best Practices and Optimization<\/h2>\n
While GCC will optimize your code by default, you can control the optimization level with the -O<\/code> option. For example, -O0<\/code> (no optimization), -O1<\/code> (optimize minimally), -O2<\/code> (optimize more), -O3<\/code> (optimize even more), -Ofast<\/code> (optimize very aggressively to the point of breaking standards), and -Og<\/code> (optimize debugging experience).<\/p>\n
GCC also includes features for warning about common mistakes (-Wall<\/code>) or even turning warnings into errors (-Werror<\/code>). Using these options can help catch issues early.<\/p>\n
Remember to always keep your system and GCC installation updated to the latest version to benefit from the latest features and bug fixes.<\/p>\n
Understanding Compilers and Their Role<\/h2>\n
To fully grasp the importance of the ‘install gcc command linux’, it’s crucial to understand what compilers do and their role in software development.<\/p>\n
What is a Compiler?<\/h3>\n
A compiler is a special program that processes statements written in a particular programming language and turns them into machine language or ‘code’ that a computer’s processor uses. In essence, it translates the human-readable code into a format that your machine can understand and execute.<\/p>\n
# Example of a C program\n#include <stdio.h>\n\nint main() {\n   \/\/ printf() displays the string inside quotation\n   printf(\"Hello, World!\");\n   return 0;\n}\n\n# Output:\n# 'Hello, World!'\n<\/code><\/pre>\n
In this example, the C compiler takes the source code and translates it into machine code. The printf()<\/code> function is a C library function that sends formatted output to stdout (your screen, by default).<\/p>\n
The Role of GCC in Software Development<\/h3>\n
GCC, the GNU Compiler Collection, includes front ends for C, C++, Objective-C, Fortran, Ada, and Go, as well as libraries for these languages. It’s a key tool in a developer’s arsenal, playing a pivotal role in converting your source code into executable programs.<\/p>\n
GCC offers various benefits, including support for multiple languages, optimization, portability, and the ability to work on multiple projects, making it a preferred choice for many developers.<\/p>\n
The Importance of Installing GCC in Linux<\/h3>\n
Linux is a popular choice for developers. It’s open-source, reliable, and supports a wide array of development tools like GCC. Having GCC installed on your Linux system allows you to compile and run your programs right from the terminal, making it an essential tool for Linux-based development.<\/p>\n
Installing GCC on Linux is as simple as running a few commands. However, understanding what these commands do and how GCC works can help you troubleshoot issues and optimize your development workflow.<\/p>\n
Delving Deeper: GCC in Larger Projects<\/h2>\n
Understanding how to install and use GCC in Linux is just the start. As you work on larger projects, you’ll find that the GCC command often works in tandem with other commands and functions. Let’s explore some of these related tools and how they can benefit your development process.<\/p>\n
Make: Automating Your Build Process<\/h3>\n
As your projects grow, compiling all your source files with individual commands can become tedious. That’s where Make comes in. Make is a build automation tool that automatically builds executable programs and libraries from source code by reading files called Makefiles.<\/p>\n
Here’s a simple Makefile for a C program:<\/p>\n
# Makefile\n\nall: hello\n\nhello: hello.c\n    gcc -o hello hello.c\n\nclean:\n    rm hello\n\n# Output:\n# 'gcc -o hello hello.c'\n<\/code><\/pre>\n
In this Makefile, all<\/code> is the default target, hello<\/code> compiles the program, and clean<\/code> removes the executable.<\/p>\n
GDB: Debugging Your Programs<\/h3>\n
Even the best developers write code with bugs. GDB, the GNU Debugger, can help you debug your programs. It lets you see what is going on ‘inside’ another program while it executes.<\/p>\n
Here’s a basic example of using GDB:<\/p>\n
gcc -g hello.c -o hello\ngdb hello\n\n# Output:\n# 'GNU gdb (Ubuntu 8.1-0ubuntu3.2) 8.1.0.20180409-git'\n# 'Reading symbols from hello...done.'\n<\/code><\/pre>\n
In this example, we first compile the program with -g<\/code> to include debugging information. Then, we run gdb hello<\/code> to start debugging the program.<\/p>\n
Valgrind: Checking Memory Leaks<\/h3>\n
Memory leaks can be a serious issue in C programs. Valgrind is a tool that can help you find memory leaks, among other things.<\/p>\n
Here’s a basic example of using Valgrind:<\/p>\n
valgrind --leak-check=yes .\/hello\n\n# Output:\n# '==2092== Memcheck, a memory error detector'\n# '==2092== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.'\n<\/code><\/pre>\n
In this example, we’re running the hello<\/code> program with Valgrind to check for memory leaks.<\/p>\n
Further Resources for Mastering GCC in Linux<\/h3>\n
To further your understanding of GCC and related tools, you can refer to the following resources:<\/p>\n
    \n
  1. GCC and Make – A Tutorial on how to compile, link and build C\/C++ applications<\/a><\/p>\n<\/li>\n
  2. \n
    A Tutorial on How to Compile C Program in Linux<\/a><\/p>\n<\/li>\n
  3. \n
    GCC: The Complete Reference<\/a><\/p>\n<\/li>\n<\/ol>\n
    These resources offer in-depth information about GCC and related topics, helping you to expand your knowledge and skills.<\/p>\n
    Wrapping Up: Mastering the GCC Command in Linux<\/h2>\n
    In this comprehensive guide, we’ve navigated the process of installing and using the GCC command in Linux, a key tool for compiling C programs.<\/p>\n
    We began with the basics, learning how to install GCC using package managers like APT for Debian-based distributions and YUM for RPM-based distributions. We then delved into more advanced territory, exploring how to install GCC from source code, how to install different versions of GCC, and how to verify your GCC installation.<\/p>\n
    Along the way, we tackled common issues you might encounter when using GCC, such as ‘command not found’, ‘no such file or directory’, and ‘undefined reference to main’, providing you with solutions for each issue. We also looked at alternative approaches to compiling C programs, exploring compilers like Clang, Intel C++ Compiler, and TinyCC, and techniques like using Makefiles and IDEs.<\/p>\n
    Here’s a quick comparison of these methods:<\/p>\n\n\n\n\n\n\n\n\n
    Method<\/th>\nPros<\/th>\nCons<\/th>\n<\/tr>\n<\/thead>\n
    GCC<\/td>\nRobust, supports many languages<\/td>\nMay require troubleshooting for some programs<\/td>\n<\/tr>\n
    Clang<\/td>\nModern, expressive diagnostics<\/td>\nLess robust than GCC<\/td>\n<\/tr>\n
    Intel C++ Compiler<\/td>\nOptimized for Intel hardware<\/td>\nProprietary, not open source<\/td>\n<\/tr>\n
    TinyCC<\/td>\nLightweight, small binary size<\/td>\nLess fully-featured than GCC<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Whether you’re just starting out with GCC or you’re looking to level up your C programming skills, we hope this guide has given you a deeper understanding of GCC and its capabilities.<\/p>\n
    With its balance of power, flexibility, and broad language support, GCC is a vital tool for any Linux-based developer. Happy coding!<\/p>\n","protected":false},"excerpt":{"rendered":"
    Are you planning to compile your C programs in Linux? You might find the task daunting, especially if you’re a beginner. However, the ‘GCC’ command, akin to a skilled translator, converts your C code into an executable program. It’s a tool that’s worth learning to install and use. GCC is readily available on most package […]<\/p>\n","protected":false},"author":1,"featured_media":14874,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[124,3,9],"tags":[],"class_list":["post-6603","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-bash","category-linux","category-sysadmin","cat-124-id","cat-3-id","cat-9-id","has_thumb"],"_links":{"self":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6603","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/comments?post=6603"}],"version-history":[{"count":7,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6603\/revisions"}],"predecessor-version":[{"id":14926,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6603\/revisions\/14926"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media\/14874"}],"wp:attachment":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media?parent=6603"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/categories?post=6603"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/tags?post=6603"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}