Fixing Fatal Error LNK1169: Step-by-Step Guide to Resolve Multiply Defined Symbols Found in Your Code

In this guide, we will walk you through the process of fixing the fatal error LNK1169, which is caused by multiply defined symbols in your code. This error is common among programmers, especially when working with complex projects involving multiple source files and libraries.

By following this step-by-step guide, you will learn how to identify and resolve the issue, ensuring your code is clean and error-free.

Table of Contents

  1. Understanding Fatal Error LNK1169
  2. Causes of Multiply Defined Symbols
  3. Step-by-Step Guide to Fix Fatal Error LNK1169
  4. FAQ
  5. Related Links

Understanding Fatal Error LNK1169

The fatal error LNK1169 occurs when the linker encounters one or more symbols with the same name defined in multiple source files or libraries. The linker is unable to resolve these symbols, resulting in the error message:

fatal error LNK1169: one or more multiply defined symbols found

This error prevents the linker from generating a valid executable or library file.

Microsoft Documentation: Linker Tools Error LNK1169

Causes of Multiply Defined Symbols

There are several common scenarios that can lead to multiply defined symbols in your code:

Global variables and functions with the same name in different source files: When you have multiple source files that define a global variable or function with the same name, the linker will encounter a conflict when trying to resolve these symbols.

Including a source file in another source file: If you include a source file (e.g., using #include "file.cpp") within another source file, the included file's symbols will be defined multiple times, leading to the LNK1169 error.

Static libraries with duplicate symbols: When you link your project against multiple static libraries that contain duplicate symbols, the linker will encounter the LNK1169 error.

Step-by-Step Guide to Fix Fatal Error LNK1169

Follow these steps to resolve the fatal error LNK1169 caused by multiply defined symbols:

Step 1: Identify Duplicate Symbols

The first step in fixing the error is to identify the duplicate symbols causing the issue. The linker will provide a list of symbols that are defined multiple times in the error message. Make a note of these symbols for further investigation.

Step 2: Locate Duplicate Definitions

Once you have identified the duplicate symbols, search your codebase and libraries for their definitions. This can be done using your IDE's search functionality or a text search tool like grep.

Step 3: Resolve Duplicate Definitions

After locating the duplicate definitions, you will need to resolve the conflicts by following one of these strategies:

Rename conflicting symbols: If the duplicate symbols are unintentional and have different purposes, simply rename one of them to avoid the conflict.

Use namespaces: Encapsulate your symbols within different namespaces to prevent naming conflicts.

Use static keyword for local symbols: If the duplicate symbol is a variable or function that should only be accessible within the same source file, declare it as static.

Use inline for small functions: If the duplicate symbol is a small function that should be included in multiple source files, declare it as inline.

Remove unnecessary #include directives: If you are including a source file within another source file, remove the unnecessary #include directive and ensure that the included file is part of your project's build process.

Resolve conflicts in static libraries: If the issue is caused by linking against multiple static libraries with duplicate symbols, you may need to modify the libraries to remove the conflicts or choose a different library that does not contain duplicate symbols.

Step 4: Rebuild Your Project

After resolving the duplicate symbol definitions, rebuild your project. If you have followed these steps correctly, the fatal error LNK1169 should be resolved, and your project should build successfully.


1. What is the difference between LNK2005 and LNK1169 errors?

The LNK2005 error occurs when a symbol is defined more than once in a project, while the LNK1169 error occurs when multiple symbols are defined. Both errors indicate a problem with multiply defined symbols, but LNK1169 is considered a fatal error that prevents the linker from generating a valid output file.

2. Can the LNK1169 error occur in C# or Java projects?

The LNK1169 error is specific to C and C++ projects using the Microsoft Visual Studio linker. However, similar errors can occur in other languages, such as Java or C#, if multiple definitions of a symbol are encountered during the compilation or linking process.

3. How can I prevent duplicate symbol errors in the future?

To avoid duplicate symbol errors, follow best practices such as using namespaces, static and inline keywords, and proper organization of your source files and libraries. Additionally, ensure that you do not include source files within other source files unnecessarily.

4. Can I ignore the LNK1169 error?

Ignoring the LNK1169 error is not recommended, as it indicates a fundamental issue with your code that can lead to unexpected behavior and runtime errors. It is essential to resolve the error by identifying and fixing the duplicate symbol definitions.

5. How can I get more information about the duplicate symbols causing the LNK1169 error?

The linker will provide a list of duplicate symbols in the error message. You can also use the /VERBOSE flag when building your project to get more detailed information about the linking process, including information about the symbols involved in the error.

Great! You’ve successfully signed up.

Welcome back! You've successfully signed in.

You've successfully subscribed to

Success! Check your email for magic link to sign-in.

Success! Your billing info has been updated.

Your billing was not updated.