Thread: Code::blocks 'undefined reference' error

I am using Code::Blocks 12.11 on Windows 8

I am following the tutorial here - Lesson 2 - Creating a basic window - Natural Language Processing, London and I am receiving the error "undefined reference to 'MainWindow::m_hInstance'" in the MainWindow.cpp file. I don't know enough about the C++ language to guage whether there is an error in the code, or (more likely) it's an error in the Code::Blocks project set-up.

I have three files: main.cpp, MainWindow.cpp, MainWindow.h

main.cpp

Code:

#include <windows.h>
#include "MainWindow.h"

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmdLine, int nCmdShow)
{
    MSG msg;

    MainWindow *winMain = new MainWindow(hInst);
    if(!winMain->Run(nCmdShow))
    {
        delete winMain;
        return 1; 
    }

    // Run the message loop. It will run until GetMessage() returns 0
    while (GetMessage (&msg, NULL, 0, 0))
    {
        // Translate virtual-key messages into character messages
        TranslateMessage(&msg);
        // Send message to WindowProcedure
        DispatchMessage(&msg);
    }

    delete winMain;

    return msg.wParam;
}

MainWindow.cpp

Code:

#include <windows.h>
#include "MainWindow.h"

char MainWindow::m_szClassName[] = "DrawLite";

MainWindow::MainWindow(HINSTANCE hInstance)
{
    m_hInstance = hInstance;
  
    m_wndClass.cbSize = sizeof(WNDCLASSEX);
    m_wndClass.style = CS_DBLCLKS;
    m_wndClass.lpfnWndProc = MainWndProc;
    m_wndClass.cbClsExtra = 0;
    m_wndClass.cbWndExtra = 0;
    m_wndClass.hInstance = hInstance;
    m_wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    m_wndClass.hCursor = LoadIcon(NULL, IDC_ARROW);
    m_wndClass.hbrBackground = (HBRUSH) COLOR_WINDOW;
    m_wndClass.lpszMenuName = NULL;
    m_wndClass.lpszClassName = m_szClassName;
    m_wndClass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

}

MainWindow::~MainWindow()
{

}

LRESULT CALLBACK MainWindow::MainWndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_DESTROY:
        PostQuitMessage (0);
        break;
    default:
        return DefWindowProc (hwnd, msg, wParam, lParam);
    }

    return 0;
}

bool MainWindow::Run(int nCmdShow)
{
    if(!RegisterClassEx(&m_wndClass))
        return false;
    m_hwnd = CreateWindowEx(
                 0,
                 m_szClassName,
                 "Draw Lite",
                 WS_OVERLAPPEDWINDOW,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                 500,
                 400,
                 NULL,
                 NULL,
                       m_hInstance,      
                 NULL
             );
    if(!m_hwnd)
        return false;
    ShowWindow(m_hwnd, nCmdShow);
    return true;
}

MainWindow.h

Code:

#ifndef MAINWINDOW_H_INCLUDED
#define MAINWINDOW_H_INCLUDED

#include <windows.h>

class MainWindow
{

public:
    MainWindow(HINSTANCE hInstance);
    ~MainWindow();

    static LRESULT CALLBACK MainWndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
    bool Run(int nCmdShow);

private:
    WNDCLASSEX m_wndClass;
    static HINSTANCE m_hInstance;
    HWND m_hwnd;
    static char m_szClassName[];

};

#endif // MAINWINDOW_H_INCLUDED

I have searched Google for undefined reference problems and have found a few posts which were solved by adding the files to the project - I have added the files by right clicking the project and choosing "add files" and making sure all the boxes are ticked.

I have also tried to add the project directry to the linker tab as described in the Codeblocks manual, and then tried to add the object file in the same way.

I have got the feeling that it is an error in the project set-up, but I'm out of ideas.

> I have three files: main.cpp, MainWindow.cpp, MainWindow.h
I believe that all you should need is in project->settings->source files, you just have the two .cpp files listed.

So when you do a full build, you should see two compile lines (for each of the .cpp files), then the linker producing the executable.

There doesn't seem to be a "settings" under the project menu (at least with the version 12.11 that I am running) - However, there is a "Properties" option and the tab "Build Targets". All three files are in the "Build Target Files" and all are selected.

It looks like the two files have been included in the compiler input - Here is the output from the 'Build Log'

Code:

-------------- Build: Debug in Win32Tuturial (compiler: GNU GCC Compiler)---------------


mingw32-g++.exe  -o bin\Debug\Win32Tuturial.exe obj\Debug\main.o obj\Debug\MainWindow.o    

obj\Debug\MainWindow.o: In function `ZN10MainWindowC2EP11HINSTANCE__':

D:/Programming/Win32Tuturial/MainWindow.cpp:8: undefined reference to `MainWindow::m_hInstance'

obj\Debug\MainWindow.o: In function `ZN10MainWindow3RunEi':

D:/Programming/Win32Tuturial/MainWindow.cpp:61: undefined reference to `MainWindow::m_hInstance'

collect2.exe: error: ld returned 1 exit status

Process terminated with status 1 (0 minutes, 0 seconds)

2 errors, 0 warnings (0 minutes, 0 seconds)

That seemed to work, thanks ZuK.

What is the reason why this needs to be done?

As I said, I don't know enough about C++ to judge if there was an error in the code.

Because it's static - there is only one instance of the variable in the program.

Thanks Elysia

So just to clarify:

A Static variable in a class is implemented as one variable which is availible to all classes
i.e. winMain1.m_hInstance and winMain2.m_hInstance are the same variable (same memory location)

A Static variable in a class must be declared in the same way a function is declared for a class. However, a non-static variable does not need to be declared in this way.

Originally Posted by Click_here

A Static variable in a class must be declared in the same way a function is declared for a class.

Not quite: a non-const static member variable that is declared in a class definition must be defined outside of the class definition, in exactly one translation unit. The same applies to const static member variables, with the exception that such variables of integer type can be defined in the class definition by initialising them to a constant there.

What do you mean by "translation unit", laserlight?

This is my current understanding:
A function can be fully defined in a class definition or external to that class definition. However, a static variable needs to be declared like a global variable, unless it is a constant integer where an exception to the rule is made on the event that a definition was imediately made.

Code:

class apple
{
  /* No further defining is needed here: */
  int banana;
  const static int grape = 4;
  apple();
  ~apple();

  /* These need to be defined again globally */
  const static int pear;
  static char pineapple[42];
  
};

Originally Posted by Click_here

What do you mean by "translation unit", laserlight?

A source file with the headers included.

Originally Posted by Click_here

What do you mean by "translation unit", laserlight?

A translation unit is a single source file (e.g. with a .cpp extension) and the collection of files it #include's. All laserlight is saying is that, if your project contains more than one source file, a non-const static member of the class is only allowed to be defined in one of them.

Originally Posted by Click_here

This is my current understanding:
A function can be fully defined in a class definition or external to that class definition. However, a static variable needs to be declared like a global variable, unless it is a constant integer where an exception to the rule is made on the event that a definition was imediately made.

Not quite. To reiterate what laserlight said, a static member of a class needs to be DEFINED outside the class, in exactly one translation unit.

A variable declaration simply tells the compiler to assume that a variable with that name and type exists, so subsequent code in that translation unit can do things to that variable (retrieve its value, change the value, etc). A definition actually causes the variable to exist. Where you are possibly getting confused is that a definition is a particular type of declaration.

A global variable may be declared in multiple translation units (eg by placing the declaration within a header file which is #include'd in multiple translation units). It must be defined in exactly one of them.

You should, if possible, use std::string for all your strings, not char arrays.

main is not used in Windows programs.
Now that I think about it, why are you using operator new here? It seems superfluous. You should probably remove it.

Originally Posted by Elysia

You should, if possible, use std::string for all your strings, not char arrays.

This tutorial uses some C string functions later on (wsprintf in particular). I might go back through the tutorial's code later and try to learn and implement some of the C++'s string functionality.

Originally Posted by Elysia

Now that I think about it, why are you using operator new here? It seems superfluous. You should probably remove it.

I am following a tutorial which has chosen to dynamically allocate the class - In fact the WinMain function was so simple, I just copied and pasted from the tutorial without a second thought. I'm not going to change it for changes sake.

Originally Posted by Aeoskype

try adding

Code:

int main()
{
 
}

at the end of program.

When programming a graphical windows based application, the entry point WinMain instead of main - Adding "main" after the WinMain is already in the code would be a bad choice.

Here it is on the MSDN website - WinMain entry point (Windows)

I think that the tutorial I have been following skims over quite a lot, but through using Google, I'm finding it quite good. However, these tutorials, as well as the MSDN site, have been heavily critisized for not using modern C++ and using C string functions (which is fine for me, because I know C very well, but not C++).