Ошибка multiple definition of first defined here

The problem here is that you are including commands.c in commands.h before the function prototype. Therefore, the C pre-processor inserts the content of commands.c into commands.h before the function prototype. commands.c contains the function definition. As a result, the function definition ends up before than the function declaration causing the error.

The content of commands.h after the pre-processor phase looks like this:

#ifndef COMMANDS_H_
#define COMMANDS_H_

// function definition
void f123(){

}

// function declaration
void f123();

#endif /* COMMANDS_H_ */

This is an error because you can’t declare a function after its definition in C. If you swapped #include "commands.c" and the function declaration the error shouldn’t happen because, now, the function prototype comes before the function declaration.

However, including a .c file is a bad practice and should be avoided. A better solution for this problem would be to include commands.h in commands.c and link the compiled version of command to the main file. For example:

commands.h

#ifndef COMMANDS_H_
#define COMMANDS_H_

void f123(); // function declaration

#endif

commands.c

#include "commands.h"

void f123(){} // function definition

The multiple definition of C++ error appears when developers include a single function in two places. As a result, the program will define the functions twice, which is invalid when working with complex files, causing multiple definition errors.

Although the solutions are not complicated and challenging to learn, debugging the error can be tedious due to the multiple definition of C++ header files. Therefore, this article answers the internet’s latest topics and questions regarding this annoying C++ error.

Why Is the Multiple Definition of C++ Error Happening?

The multiple definition of C++ pragma once error happens when developers include the fun.cpp function in two places. For instance, programmers must not use CPP files when creating the function. Instead, they must use the header files that do not produce mistakes and affect other commands.

However, this is easier said than done because it is sometimes essential for programmers to include multiple definitions in a single document. Furthermore, this error mostly happens with less experienced users because they do not know how to replace the CPP files.

Furthermore, the multiple definition of C global variable affects similar functions inside a single document, corresponding with the definitions. Instead, our experts believe the header documents must have separate class definitions, and the CPP file must have the function definition.

This error occurs when programmers misplace the commands and include different values. For example, some developers keep the prototypes and descriptions in a single file, causing the system to display errors.

On the flip side, not linking the separate files appropriately will trigger the error and display it over your program. Therefore, separating the prototypes and definitions does not remove the error, which is annoying when working on complex files. So, the multiple definition of first defined here helps customers understand the detail. But first, we’ll discover the syntax that causes the bug.

– Using a Friend Function Displays the Error

Developers can encounter this error by including friend functions inside multiple definitions of X in C++, mixing the values and commands. However, this rookie mistake can sometimes destroy your user experience and prevent you from finishing the project.

In addition, the friend function interferes with the header documents and breaks the primary commands.

The following example includes the fun.cpp function with its good values:

This is the code’s first part because developers must include a separate document for the main file.

Programmers can include as many or as few elements and values in the document, but we kept the syntax short and straightforward. Still, the concise code lines cause the error to appear without affecting other secondary functions.

Here is the second part of the code that displays the multiple definition of class C++ error:

As you can see, this code completes the syntax and displays the error caused by declaring the friend function. But first, let us break down the error syntax to discover the three main processes and machine executables.

– C++ Error Syntax Splitting Phases

The previous syntax consists of two main parts, initiating three splitting phases that execute the machine code. Although all correct syntaxes include the same processes, the multiple commands of C++ error follow the basic principle but fail to compile the functions.

The first process is called preprocessing, where developers include macros and define the tasks that will get expanded. Fortunately, the multiple command error does not appear in the primary step, so that the program will complete the preprocessing efficiently.

The following step is called compiling because C++ implements the include function for the direct and indirect files. As a result, the program checks all parts by confirming if it can provide a single declaration for the commands.

Although developers can complete this function in the header documents, the program defines the functions in the CPP files. As a result, the program will correspond to functions defined in the CPP syntax and omit the commands without declarations.

The last step is called linking because the program matches declared links to where they belong. Therefore, the program will display an error if it comes across a function without declaration because it cannot reach a good place.

This is the step where C++ shows the multiple command error and ruins your programming experience. However, defining and debugging the issue is not complicated.

How to Fix the Multiple Definition of C++ Error?

Providing a separate class definition for the header and function definition for the CPP file is the most prolific solution to this standard error. However, our experts do not recommend including two fun.cpp functions in your document separately because the program defines the term twice.

As a result, C++ does not know which function to initiate first, causing the error to pop and stop your operations from working correctly. Although this is logical and does not usually happen with experienced users, making mistakes is natural.

Still, knowing how to react is critical because the program will not debug the error. Instead, developers must change the syntax and split the functions, which is not challenging or time-consuming.

Although our examples are different from your syntax, the principles are identical, so we recommend repeating our steps to avoid making errors. Therefore, you should not worry if your C++ document looks different. In addition, the fun.hpp function does not have many forms, so you can quickly recognize the similarities.

– Debugging the Error by Splitting the Syntaxes

Our experts recommend splitting the complete syntax into several parts to help you activate the functions and remove the error. For instance, creating different documents for the fun.hpp, fun.cpp, and mainfile.cpp functions would be best because you will not mistake the tags and elements.

In addition, our customers recommend avoiding using the namespace std function in header documents because it can confuse the program.

This example shows the fun.hpp syntax and its functions, tags, and elements:

The syntax in your document will be complete, but it will not affect your debugging setup. Next, we must separate the fun.cpp function in a different document, as shown in this example:

This example states the fun.hpp function in the header element, forming the path with the previous syntax without disturbing primary and secondary processes. In addition, the void function states the program’s purpose, which can be as long or short as you like.

The last part of the syntax requires developers to include the mainfile.cpp, as shown here:

The C++ program will erase the error if you include this syntax in your document. So, this example shows nothing is impossible in working with C++.

Conclusion

The typical multiple commands of C++ error happen when developers and programmers include a single function in two places, confusing the system. Therefore, although we provided the error’s solution syntaxes and steps, this article also covered the following critical points:

• Including a single function in two places means the C++ program will define the commands twice, which is incorrect
• Typical CPP and HPP functions create this error because they contain the wrong elements
• Your complete error syntax might be different, but the solution practice remains identical
• The most refined way of fixing this error is creating separate documents with the HPP and CPP functions
• This C++ error might affect parent and child elements and tags

Developers have dynamic experience working with C++ because it can display unexpected errors and bugs with seemingly correct documents. As a result, this guide debugged the error, provided the solution syntax, and taught you about C++ multiple command errors.