unresolved external

Question

I have an unresolved external symbol error that's driving me nuts. In short, I have a wrapper class for SDL_Surfaces ('DgSurface') and a class to load and store DgSurfaces ('DgSurfaceList'). The link issue arises when trying to include the DgSurfaceList files in my project. Here are my classes:

The header file "DgSurface.h" contains the DgSurface class declaration:

    #ifndef DGSURFACE_H
    #define DGSURFACE_H

    #include "SDL.h"
    #include <string>

    class DgSurface
    {
    public:

        //Constructor/destructor
        DgSurface(std::string N, SDL_Surface* I): image(I), name(N) {}
        DgSurface() {name = ""; image = NULL;}
        ~DgSurface();

        //Copy operations
        DgSurface(const DgSurface&);
        DgSurface& operator= (const DgSurface&);

        //Data members
        std::string name;       //The name of the image
        SDL_Surface* image;     //The image
    };

    #endif

The cpp file "DgSurface.cpp" contatins DgSurface definitions:

#include "DgSurface.h"
#include "SDL.h"

//--------------------------------------------------------------------------------
//        Constructor
//--------------------------------------------------------------------------------
DgSurface::DgSurface(const DgSurface& other)
{
    //Copy name
    name = other.name;

    //Create new SDL_Surface 
    image = SDL_ConvertSurface(other.image, other.image->format, 0);
}


//--------------------------------------------------------------------------------
//        Destructor
//--------------------------------------------------------------------------------
DgSurface::~DgSurface()
{
    SDL_FreeSurface(image);
}


//--------------------------------------------------------------------------------
//        Assignment operator
//--------------------------------------------------------------------------------
DgSurface& DgSurface::operator= (const DgSurface& other)
{
    // if same object
    if ( this == &other )
        return *this;

    //Copy name
    name = other.name;

    //Create new SDL_Surface 
    image = SDL_ConvertSurface(other.image, other.image->format, 0);

    return *this;
}

This class seems to work fine and performs as expected (however, as always, am open to feedback :).

"DgSurfaceList.h" contains DgSurfaceList class declarations:

#ifndef DGSURFACELIST_H
#define DGSURFACELIST_H

#include "SDL.h"
#include <list>
#include <string>
#include "DgSurface.h"


class DgSurfaceList
{
    public:
        //Constructors/destructor
        DgSurfaceList() {}
        ~DgSurfaceList() {}

        //Functions
        bool AddImage(std::string location, std::string name);

        //Return Functions
        SDL_Surface* GetImage(std::string S) const;

    private:
        //Data members
        std::list<DgSurface> imlist;    //The list of DgSurfaces

        //Functions
        SDL_Surface* LoadImage( std::string filename );
};


#endif

and finally "DgSurfaceList.cpp" contains DgSurfaceList definitions:

#include "SDL.h"
#include "SDL_image.h"
#include <list>
#include <string>
#include "DgSurface.h"
#include "DgSurfaceList.h"


//--------------------------------------------------------------------------------
//      Load an image from file
//--------------------------------------------------------------------------------
SDL_Surface* DgSurfaceList::LoadImage( std::string filename )
{
    //Loads an image from file, returns SDL_surface*
    ...

}   //End:DgSurfaceList::LoadImage()


//--------------------------------------------------------------------------------
//      Add a DgSurface to the list
//--------------------------------------------------------------------------------
bool DgSurfaceList::AddImage(std::string location, std::string name) 
{
    //Load the image
    DgSurface temp(name,LoadImage(location));

    //If there was an error in loading the image
    if( temp.image == NULL )
        return false;

    //If everything loaded fine, place a copy into imlist
    imlist.push_back(temp);

    return true;

}   //End: DgSurfaceList::AddImage();


//--------------------------------------------------------------------------------
//      Searches imlist for an image, returns a pointer to a SDL_Surface
//--------------------------------------------------------------------------------
SDL_Surface* DgSurfaceList::GetImage(std::string S) const
{
    std::list<DgSurface>::const_iterator i;

    //Search imlist for DgSurface of the same name
    for (i = imlist.begin(); i != imlist.end(); i++)
    {
        if (S.compare((*i).name) == 0)
            return (*i).image;
    }

    //Return Null if name not found
    return NULL;

}   //End:DgSurfaceList::GetImage()

Now, if I comment out the DgSurfaceList::GetImage() definition in the cpp file, DgSurfaceList seems to work fine and store images correctly. More specifically, the link error only arises when I include the for loop in the above function. What could it be?

Other info:

Error:

unresolved external symbol __imp___CrtDbgReportW referenced in function "public: class 
DgSurface const & __thiscall std::_List_const_iterator<class std::_List_val<class 
DgSurface,class std::allocator<class DgSurface> > >::operator*(void)const "

Coding environment: Visual C++ express 2010

Answer 1

CrtDbgReport is defined in the debug version of the C run time library only. So perhaps you are compiling in debug mode but linking with the release version of the library. Another possibility is that you are compiling in release mode but that some macro you have defined is causing the debug version of std::list to be compiled.