Question

I have a C++/Win32/MFC project in Visual Studio 2008, and I’m getting a strange error message when I compile it.

I’ve created a small project to demonstrate the problem, and the main code is

#ifndef _MyObject_h
#define _MyObject_h

class MyObject
{
public:
        MyObject()
        {
        }
};

#endif // _MyObject_h
// --- END MyObject.h



// --- BEGIN ObjectData.h
#ifndef _ObjectData_h
#define _ObjectData_h

template <typename DataPolicy>
class ObjectData
{
public:
        DataPolicy *data;

        ObjectData() :
                data(NULL)
        {
        }

        ObjectData(const ObjectData<DataPolicy> &copy) :
                data(copy.data)
        {
        }

        ObjectData<DataPolicy> & operator=(const ObjectData<DataPolicy> &copy)
        {
                this->data = copy.data;
                return *this;
        }
};

#endif // _ObjectData_h
// --- END ObjectData.h



// --- BEGIN Tool.h
#ifndef _Tool_h
#define _Tool_h

#include "ObjectData.h"

template <typename ObjectPolicy>
class Tool
{
private:
        ObjectData<typename ObjectPolicy> _object;

public:
        Tool(ObjectData<typename ObjectPolicy> obj);
};

#endif // _Tool_h
// --- END Tool.h



// --- BEGIN Tool.cpp
#include "stdafx.h"
#include "Tool.h"

template <typename ObjectPolicy>
Tool<ObjectPolicy>::Tool(ObjectData<typename ObjectPolicy> obj) :
        _object(obj)
{
}
// --- END Tool.cpp



// --- BEGIN Engine.h
#ifndef _Engine_h
#define _Engine_h

#include "Tool.h"
#include "MyObject.h"

class Engine
{
private:
        MyObject *_obj;

public:
        Engine();
        ~Engine();
        void DoSomething();
};

#endif // _Engine_h
// --- END Engine.h



// --- BEGIN Engine.cpp
#include "stdafx.h"
#include "Engine.h"

Engine::Engine()
{
        this->_obj = new MyObject();
}

Engine::~Engine()
{
        delete this->_obj;
}

void Engine::DoSomething()
{
        ObjectData<MyObject> objData;
        objData.data = this->_obj;
        // NEXT LINE IS WHERE THE ERROR OCCURS
        Tool< ObjectData<MyObject> > *tool = new Tool< ObjectData<MyObject> >(objData);
}
// --- END Engine.cpp

Errors:

Engine.cpp
c:\projects\myproject\myproject\engine.cpp(18) : error C2664:
‘Tool::Tool(ObjectData)’ : cannot convert parameter 1 from ‘ObjectData’ to ‘ObjectData’
with
[
ObjectPolicy=ObjectData,
DataPolicy=ObjectData
]
and
[
DataPolicy=MyObject
]
and
[
DataPolicy=ObjectData
]
No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
1>Build log was saved at “file://c:\Projects\MyProject\MyProject\Debug\BuildLog.htm”
MyProject – 1 error(s), 0 warning(s)

Thanks for any help.

Answer 1

There are a few problems with your code. First of all, you are using the typename keyword in a wrong way. typename can be used only when qualified type names are used (and is required when the type names are dependent), which is not your case:

template <typename ObjectPolicy>
class Tool
{
private:
    ObjectData<typename ObjectPolicy> _object; // "typename" is not needed!
public:
    Tool(ObjectData<typename ObjectPolicy> obj); // "typename" is not needed!
};

The problem you complain about, however, is in your instantiation of the Tool class template:

Tool< ObjectData<MyObject> > *tool = new Tool< ObjectData<MyObject> >(objData);

Your Tool<> template contains a member variable of type ObjectData<ObjectPolicy>, where ObjectPolicy is the class template parameter. However, in the line above you instantiate Tool with ObjectData<MyObject> as a parameter. This means your member variable will have type ObjectData<ObjectData<MyObject>>, and this will also be the type of the constructor’s parameter.

Because of this, you are trying to invoke a constructor which accepts an ObjectData<ObjectData<MyObject>> with an argument of a mismatching type ObjectData<MyObject>. Hence, the error you get.

You should change your instantiation into:

Tool< MyObject > *tool = new Tool< MyObject >(objData);

Another problem is that you have the definition of Tool‘s member functions in a separate .cpp files. You should not do that: the linker won’t be able to see it when processing a separate translation unit.

To solve this problem, put the definitions of your class template’s member functions into the same header where the class template is defined (Tool.h in your case).