2.6 — Forward declarations and definitions

Take a look at this seemingly innocent sample program:

You would expect this program to produce the result:

The sum of 3 and 4 is: 7

But in fact, it doesn’t compile at all! Visual Studio produces the following compile error:

add.cpp(5) : error C3861: 'add': identifier not found

The reason this program doesn’t compile is because the compiler compiles the contents of code files sequentially. When the compiler reaches the function call to add on line 5 of main, it doesn’t know what add is, because we haven’t defined add until line 9! That produces the error, identifier not found.

Older versions of Visual Studio would produce an additional error:

add.cpp(9) : error C2365: 'add' : redefinition; previous definition was 'formerly unknown identifier'

This is somewhat misleading, given that add wasn’t ever defined in the first place. Despite this, it’s useful to generally note that it is fairly common for a single error to produce many redundant or related errors or warnings.

Best practice

When addressing compile errors in your programs, always resolve the first error produced first and then compile again.

To fix this problem, we need to address the fact that the compiler doesn’t know what add is. There are two common ways to address the issue.

Option 1: Reorder the function definitions

One way to address the issue is to reorder the function definitions so add is defined before main:

That way, by the time main calls add, the compiler will already know what add is. Because this is such a simple program, this change is relatively easy to do. However, in a larger program, it can be tedious trying to figure out which functions call which other functions (and in what order) so they can be declared sequentially.

Furthermore, this option is not always possible. Let’s say we’re writing a program that has two functions A and B. If function A calls function B, and function B calls function A, then there’s no way to order the functions in a way that will make the compiler happy. If you define A first, the compiler will complain it doesn’t know what B is. If you define B first, the compiler will complain that it doesn’t know what A is.

Option 2: Use a forward declaration

We can also fix this by using a forward declaration.

A forward declaration allows us to tell the compiler about the existence of an identifier before actually defining the identifier.

In the case of functions, this allows us to tell the compiler about the existence of a function before we define the function’s body. This way, when the compiler encounters a call to the function, it’ll understand that we’re making a function call, and can check to ensure we’re calling the function correctly, even if it doesn’t yet know how or where the function is defined.

To write a forward declaration for a function, we use a declaration statement called a function prototype. The function prototype consists of the function’s return type, name, parameters, but no function body (the curly braces and everything in between them), terminated with a semicolon.

Here’s a function prototype for the add function:

Now, here’s our original program that didn’t compile, using a function prototype as a forward declaration for function add:

Now when the compiler reaches the call to add in main, it will know what add looks like (a function that takes two integer parameters and returns an integer), and it won’t complain.

It is worth noting that function prototypes do not need to specify the names of the parameters. In the above code, you can also forward declare your function like this:

However, we prefer to name our parameters (using the same names as the actual function), because it allows you to understand what the function parameters are just by looking at the prototype. Otherwise, you’ll have to locate the function definition.

Best practice

When defining function prototypes, keep the parameter names. You can easily create forward declarations by using copy/paste on your function declaration. Don’t forget the semicolon on the end.

Forgetting the function body

New programmers often wonder what happens if they forward declare a function but do not define it.

The answer is: it depends. If a forward declaration is made, but the function is never called, the program will compile and run fine. However, if a forward declaration is made and the function is called, but the program never defines the function, the program will compile okay, but the linker will complain that it can’t resolve the function call.

Consider the following program:

In this program, we forward declare add, and we call add, but we never define add anywhere. When we try and compile this program, Visual Studio produces the following message:

add.obj : error LNK2001: unresolved external symbol "int __cdecl add(int,int)" ([email protected]@[email protected])
add.exe : fatal error LNK1120: 1 unresolved externals

As you can see, the program compiled okay, but it failed at the link stage because int add(int, int) was never defined.

Other types of forward declarations

Forward declarations are most often used with functions. However, forward declarations can also be used with other identifiers in C++, such as variables and user-defined types. Variables and user-defined types have a different syntax for forward declaration, so we’ll cover these in future lessons.

Declarations vs. definitions

In C++, you’ll often hear the words “declaration” and “definition” used, often interchangeably. What do they mean? You now have enough of a framework to understand the difference between the two.

A definition actually implements (for functions or types) or instantiates (for variables) the identifier. Here are some examples of definitions:

A definition is needed to satisfy the linker. If you use an identifier without providing a definition, the linker will error.

The one definition rule (or ODR for short) is a well-known rule in C++. The ODR has three parts:

  1. Within a given file, a function, object, type, or template can only have one definition.
  2. Within a given program, an object or normal function can only have one definition. This distinction is made because programs can have more than one file (we’ll cover this in the next lesson).
  3. Types, templates, inline functions, and variables are allowed to have identical definitions in different files. We haven’t covered what most of these things are yet, so don’t worry about this for now -- we’ll bring it back up when it’s relevant.

Violating part 1 of the ODR will cause the compiler to issue a redefinition error. Violating ODR part 2 will likely cause the linker to issue a redefinition error. Violating ODR part 3 will cause undefined behavior.

Here’s an example of a violation of part 1:

Because the above program violates ODR part 1, this causes the Visual Studio compiler to issue the following compile errors:

project3.cpp(9): error C2084: function 'int add(int,int)' already has a body
project3.cpp(3): note: see previous definition of 'add'
project3.cpp(16): error C2086: 'int x': redefinition
project3.cpp(15): note: see declaration of 'x'

For advanced readers

Functions that share an identifier but have different parameters are considered to be distinct functions. We discuss this further in lesson 10.7 -- Function overloading

A declaration is a statement that tells the compiler about the existence of an identifier and its type information. Here are some examples of declarations:

A declaration is all that is needed to satisfy the compiler. This is why we can use a forward declaration to tell the compiler about an identifier that isn’t actually defined until later.

In C++, all definitions also serve as declarations. This is why int x appears in our examples for both definitions and declarations. Since int x is a definition, it’s a declaration too. In most cases, a definition serves our purposes, as it satisfies both the compiler and linker. We only need to provide an explicit declaration when we want to use an identifier before it has been defined.

While it is true that all definitions are declarations, the converse is not true: all declarations are not definitions. An example of this is the function prototype -- it satisfies the compiler, but not the linker. These declarations that aren’t definitions are called pure declarations. Other types of pure declarations include forward declarations for variables and type declarations (you will encounter these in future lessons, no need to worry about them now).

The ODR doesn’t apply to pure declarations (it’s the one definition rule, not the one declaration rule), so you can have as many pure declarations for an identifier as you desire (although having more than one is redundant).

Author's note

In common language, the term “declaration” is typically used to mean “a pure declaration”, and “definition” is used to mean “a definition that also serves as a declaration”. Thus, we’d typically call int x; a definition, even though it is both a definition and a declaration.

Quiz time

Question #1

What is a function prototype?

Show Solution

Question #2

What is a forward declaration?

Show Solution

Question #3

How do we declare a forward declaration for functions?

Show Solution

Question #4

Write the function prototype for this function (use the preferred form with names):

Show Solution

Question #5

For each of the following programs, state whether they fail to compile, fail to link, fail both, or compile and link successfully. If you are not sure, try compiling them!


Show Solution


Show Solution


Show Solution


Show Solution

2.7 -- Programs with multiple code files
2.5 -- Why functions are useful, and how to use them effectively

323 comments to 2.6 — Forward declarations and definitions

  • fould12

    add.obj : error LNK2001: unresolved external symbol "int __cdecl add(int,int)" ([email protected]@[email protected])

    ([email protected]@[email protected]) Makes me think of "add?...YAHHH!!"

  • Da-Rage44

    I have a stupid question, what does it actually mean by the program never defines the function?

    Do we assume we need a return value to define a function?

    • If you only make a forward declaration and never actually make the function the program never actually makes the function, meaning you will get errors when you're trying to use the forward declaration.
      No you don't need a return value to declare a function (void), it just needs to be declared somewhere (it doesn't even need to have code in it).

    • Alex

      > what does it actually mean by the program never defines the function?

      It means the program doesn't define a function body (the part of the function between the curly braces).

  • misserwell

    Thank you very much, the article is so clear , hope more and more visitor knows the web

  • donblas

    i know its been a while since this was used, but how do you make a program that does more than add a bunch of numbers?

  • Steven

    Love the tutorials,
    It says to declare a function you don't need to define it. Then in the definition for function prototype it's a "declaration of a function that includes the function’s name, parameters, and return type"

    But when I try to compile

    It tells me add() can't take 2 arguments, and forces me to declare

    at the beginning before it will compile/work. Wouldn't that be a declaration WITH a function prototype? or should

    work at the beginning and I'm doing something wrong.

    • Alex

      Your forward declaration of add has no parameters, but your definition of add has two. There's a mismatch there that's causing the problem. Fix the forward declaration so it has two parameters.

  • Anders Melen

    This tutorial is Perfect! Thank you so much for taking the time to help others learn a new great programming language! This could surly being published!, but thanks for making it available to all!

  • That was exactly what i needed ! Thank you for your support ! =)

  • StelStav

    Hi all,

    I would like to ask what is the reasoning of c++ creators for forward declaration? Why isn’t the compiler designed in such a manner so as to look for a function definition regardless of it being before or after the actual function calling?
    I would imagine that it is enough that the function definition resided in the same scope of the function call.
    Would the above (my) logic effect the efficiency of the executable or just the compilation?

    Thanks in advance

    very nice site btw, good job admins :)

    • Alex

      C++ was developed a long time ago when computers were slow and memory was expensive. I suspect this limitation was done for efficiency/simplicity, so the compiler doesn't have to parse the file more than once, or maintain memory-intensive lookup tables for all function calls.

      More modern languages (like C#) allow you to declare functions in any order without forward declarations. It's unfortunate that C++ hasn't added this.

    • Darren

      Note that these beginner tutorials are using simple programs that are most conveniently written in just one source file. That means putting the function declaration in the source file with the main function. In "real world" programs function declarations will typically exist in header files so that they can be included by several source files possibly in a number of different programs. This is called programming by contract.

      For example, standard header files, such as <iostream>, define the standard routine library’s contract with the C++ programmer, promising you use of the functions and operators declared there in. All you need is the header file included in your source code; the linker will build the implementation details in to your code without you having to worry about those details. Without the declarations you would be forced to include the library implementations in your source code every time you wish to use one of the library functions. This would be tedious and cumbersome and programmers are inherently lazy, myself included.

  • tcp

    okay so sometimes when i get to

    int add(int x, int y);
    return x + y;

    the little dropdown-menu-checkbox doesn't appear. why is this? the little alert box to the left of the code is green, so it's not registering as a problem, but it refuses to run the program unless int add is a dropdown item. (the code is perfect, the only difference between the site's code and my own is the dropdown box).

    the error message:

    error C2447: '{' : missing function header (old-style formal list?)

    • Auge

      Lets have a look at your code:

      The semicolon after the function header must be dropped:

      The error message tells you that the compiler doesn't recognize to which function the part within the curly brackets belongs to.
      That's also because of the semicolon after the function header.

  • Its very great tutorial , it's helpful and very good.
    thank you for putting together this wonderful lessons.

  • Jeno


    Thanks for this wonderful website!!!

    I wrote the following code, it compiles, links and executes well, but it seems like the Return Value is wrong:

    The output return value I get is -6, but when I compute the numbers myself it is a wrong calculation.

    What Am I missing?

    • Michael B

      Order of Operations.

      PEMDAS is it?

    • Ireul

      Sorry for disrespectful comment, but you miss grade school math classes.

      7 + 8 - 3 * 7 = 15 - 21 = -6, the answer given by output is perfectly correct.

    • Liquidcool

      Rule 1: First perform any calculations inside parentheses.
      Rule 2: Next perform all multiplications and divisions, working from left to right.
      Rule 3: Lastly, perform all additions and subtractions, working from left to right.

  • Michael O.

    Hi Alex!

    Thanks a lot for these great tutorials, they've teached me a lot (I began 2 days ago).
    I agree with comment #1, these tutorials deserve a publication! I have tried to learn C++ some times before, but all the books I ended up with were hard to understand, the language was difficult, but these tutorials are very easy to understand, so again, thanks a lot Alex!

    -Michael O.

  • Florian


    I was thinking about it for a second, here is my explanation maybe someone can tell me if i am right.

    The program does work because c++ is compiled rather than interpreted. Which means as soon as we have created a prototyp the compiler gets through until the end and the compiled program has overwriten the first Prototype with the completed declaration (since the later declaration supersedes the first statement?


    • Eugene

      Not quite. The prototype does not get overwritten. Rather, the forward declaration informs the compiler of how a call of that function should look like, and thus the compiler can do the necessary setup and translate the function call into assembly/machine code.

      The function definition defines the code that will be executed when the function is called. In this case it is in the same source file as the function call, but it could be in a different source file, or might not even be available at all, e.g., just the object code is available in a shared library.

      That said, some functions whose function definitions are available might be inlined, i.e., the function call is replaced by the code of the function itself.

  • Florian

    i do have a problem understanding this:

    As the tutorial has stated earlier the program is running line by line so the function add would be unrecognized when it is called while add() is declared later on.

    On this example I would actually realize that we have created add() called it in main BUT we never reach the line where return x+y was written down.

    Basically I would expect a link error since the call ends up without returning anything?

    So my question is why does the program knows that add() returns the value x+y when it shouldn't reach that declaration?

    Hope someone can understand this, i am German my English certainly lacks a bit.


  • Jon

    I don't know if this was mentioned yet, on a brief scan I didn't see it, so forgive me if you already answered this...
    You defined a function prototype as:

    A function prototype is a declaration of a function that includes the function’s name, parameters, and return type, but does not implement the function. In Question #2 on this page you give us:

    Did you mean us to solve for the forward declaration? If not, and you did mean to ask for the Function Prototype, shouldn't you have given us only the Forward Declaration?

  • Prayrit

    This is a weird concept to me, because every other language I've worked with(java, c#, actionscript) doesn't care where the function is located...

  • Danny

    Y doesn't it work? =/ can someone please help

    • Furious Sideburns

      I'll have a crack at answering this (I'm new to all this myself). If I'm understanding this right, you've got a few syntax errors.

      You're missing a " at the end of your first #include

      should be

      Also, you need to lose the ; on the end of your forward declaration and your add function


      should be


      • csvan

        You almost got it, however you NEED to have a ; at the end of forware declarations, since they are statements. Thus, it is compleely correct to write:

        but not without the semicolon. C++ statements are ALWAYS concluded with semicolon (except for some structures, such as while and for loops).

        Also, you CANNOT write a parameters name as a number (for example int add(int 1);), that is not allowed by the compiler.

        Keep on coding. Use it for good. :)

    • csvan

      You have 3 errors here:

      1. The first line is missing a closing quotation mark (") at the end (it should be "stdafx.h").

      2. The second include statement does not include anything. I think you meant to include iostream, therefore it should read:

      3. The name of a parameter (or any variable as far as I know) can never start with a number, or simply be a number. Therefore, you will have to rename the parameters both in the function prototype and definition for add, for example like this:

      and make the same changes to the body of the function (change 1 to a etc).

      Keep coding. Use it for good.

  • Justin

    Hi i have a question... i wrote my own code (same as yours but didn't copy and paste) and i got a weird error that i do not under stand here is my code

    and this is the error message: 3 D:Dev-Cppmain.cpp expected `,' or `;' before '{' token


  • i m very weak in programing how can i improve it

    • Practice makes perfect! Pick a small project and figure out how to code it. Eg. a calculator, an address book, a little game, etc... You will learn as much from working on your own code and solving the problems you run into as you will from these tutorials.

      • csvan

        I double that. And triple it. I believe practical work is absolutely essential to building solid programming competence. You can learn all your life, but learning is in vain if it is only forgotten. Putting learnt knowledge into practice helps solidify it, and, I believe, can really contribute to it becoming a permanent part of your routine, not easily forgotten.

  • Julian

    I just found this site today after frustratingly leaving a different "learn C++" website, and I must say, your tutorials are a 100 times better than the other site I was on! :P

    It had about one paragraph on functions which was badly worded, and then went on to something about arrays and loops and binary trees and it had examples but they used functions in a way I didn't even know was possible and it just confused the crackers outta me.

    I like the way these tutorials don't teach everything about 'functions' in the one chapter, they teach the aspects of functions that would be easy to understand at this point, and then explain the more advanced features when the reader has a bit more knowledge about C++.

    Thankyou! :D

  • peddi

    Can we say the forward declaration in nothing but declaring the function globally, where as function prototyping is declaring function locally i.e, in the main function? is that only the difference? If then there is no way we can block the outsider from accessing our function which declared using forward declaration?

    • A forward declaration is a specific type of function prototype that allows you to declare a function before you actually define it. Unfortunately, there's no way to "hide" such functions from "outsiders" -- even if you don't declare a function prototype, someone who wanted to use your function could write a function prototype for it and then use it.

      The only way to hide functions is to put them inside classes, which we'll cover much later in this tutorial.

  • adam

    in solution one it says eturn instead of return

    [ Fixed! Thanks. -Alex ]

  • adam

    So a function prototype is a kind of forward declaration?

    • It's more accurate to say that one use of function prototypes is for forward declarations. Function prototypes can also be used in header files and in class declarations (covered in chapter 8). So function prototypes have more uses than just as forward declarations.

  • jeff

    i am experimenting the code from the quiz number 6 and i try to changed the forward declaration variables


    after that i compiled the code by using microsoft visual studio 2008 and i notice that the code is successfuly compiled and the program is smoothly running.

    why is it that the compiler is not complaining while the forward declaration variable is different from the implementation?

    • Good question! It turns out that the variable names in your forward declarations don't have to match those in the actual definitions. This is because the variable names in the forward declarations simply aren't used -- only the types are. You can even omit the variable names from the forward declaration altogether if you want.

      However, I think it's generally good practice to put them in. If you see a forward declaration like this:

      It's a lot less meaningful than if you see this:

  • This helped explain a lot of things I was previously having problems with.

  • Mitul

    /* I have writen one another Program like example 5*/

    #include <iostream.h>
    #include <conio.h>

    int add(int x, int y, int z);

    void main()
    int x,y,z;
    cout << "n Enter three number : n";
    cin >> x;
    cin >> y;
    cin >> z;
    cout << "n" << x << " + " << y << " + " << z << " = " << add(x, y, z) << endl;

    int add(int x, int y, int z)
    return x + y + z;

    • Doesn't main have to be:


      so that main returns a value?

      • Many (most?) compilers let you get away with using void main() instead of int main(), and they will implicitly return 0 when you do this. However, it's not technically part of the language, so I avoid it in my examples.

    • ice

      I tried to run your program and came up with and error like this
      1>------ Build started: Project: 1, Configuration: Debug Win32 ------
      1> 1.cpp
      1>c:\users\marius\documents\visual studio 2010\projects\1\1\1.cpp(2): fatal error C1083: Cannot open include file: 'iostream.h': No such file or directory
      ========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

      • iLexy

        Since you use MSVS, you do not need to specify a library file, it takes care of that part for you so:

        #include <stdafx.h>
        #include <iostream>

  • Gary

    Hi there. I was wondering how come I have to type #include stdafx.h now. I haven't used my compiler for a while, so I was just wondering. I can't do this program unless I do it, but the Hello World one works just fine without it.

    By the way, in my older programs, the source files say "main.cpp" but the new one has 2 files, one that says stdfax.cpp and another one with the title of my project.

    I'm new to programming, so if my questions sound dumb, bear with me.

    • stdafx.cpp is a file that Microsoft compilers use to do precompiled headers (which makes you program compile faster), if you sent them up correctly. If you don't want to deal with stdafx.h, you can always turn precompiled headers off (in the project settings).

    • Darren

      8 years later but still quite relevant.

      In more recent versions of Visual Studio there is an option to create an empty project which has the 'pre-compiled headers' option (plus some others) switched off by default. Unless specifically building an app for Windows I would recommend always starting a project as an "empty project"; you can always switch the various options back on at a later date.

  • Dan

    Ahh, ok... I'm getting a clearer picture of this now (re: my question a few days ago in the previous 'functions' section
    when I asked about the order of functions in Cpp code). This helps explain the reasons why it must be. :)

    Thanks Alex!

  • GovZ,

    Forward declarations are used only to tell the compiler about the existence of a function (or class or variable) before it is actually implemented.

    This information is only used during compile time. Consequently, forward declarations will not make your executables larger or slower.

  • GovZ

    Hello guys,

    You have a great tutorial here. Worthy of publication, IMHO.

    Anyways one question. Does Forward Declaration by function prototyping have an effect on the execution time or is this only used during the creation of some hash table or something? And that in the resulting executable, this step is not actually "re-read".

    I hope I make sense. Thanks for your answers in advance. =)

Leave a Comment

Put all code inside code tags: [code]your code here[/code]