invalid use of incomplete type ‘class

[Molson]

Hello,
I've a problem with my template class:

template <class KeyType, class ValueType>
class Dictionary
{
        public:
                virtual ~Dictionary() { }

                virtual bool search(const KeyType& k) = 0;

...
}


template <class KeyType, class ValueType>
class DictAsMap : public Dictionary<KeyType,ValueType>
{
         public:
                 DictAsMap();
                 virtual ~DictAsMap();
                 virtual bool search(const KeyType& k);
...
}

template <class KeyType, class ValueType>
bool DictAsMap<KeyType, ValueType>::search(const KeyType& k)
{
...
}

template <class ValueType >
bool DictAsMap<int, ValueType>::search(const int& k)
{
...
} 

i get following compilier message:

g++ -g -W -Wall -ansi -pedantic -c -o main.o main.cpp
In file included from main.cpp:17:
DictAsMap.h:86: error: invalid use of incomplete type ‘class DictAsMap<int, ValueType>’
DictAsMap.h:14: error: declaration of ‘class DictAsMap<int, ValueType>’

What is wrong??

BR Molson

[kbw]

search would need to be a template. You may want to consider removing that inheritance hierarchy with those virtual functions.

[Molson]

i can't remove the inheritance hierarchy, because the class dictionary have to be an abstract class. so it's necessary to mark the functions as virtual.

I like to creat two search funktions one for int keys and one for string keys.
what can i do??

[vukki]

As far as i understand what you've intended to do, you need partial specialization for DictAsMap before the body of function:

template <class ValueType>
class DictAsMap<int,ValueType> : public Dictionary<int,ValueType>
{
         public:
                 DictAsMap();
                 virtual ~DictAsMap();
                 virtual bool search(const int& k);
};
template <class ValueType>
bool DictAsMap<int,ValueType>::search(const int& k)
{
...
}

and the ';' after the DictAsMap and Dictionary declarations

[kbw]

The partially specialised function won't appear in the vtable.

Your abstraction doesn't seem quite right to me. Have you really thought about what it means to attempt partially specialise a virtual function?

[Molson]

thats my problem! I like to specialise a virtual function, partially.
But it's clear to me to do that.

[kbw]

It's meaningless as you've described it.

I think you really mean:

template <class KeyType, class ValueType>
class DictAsMap : public Dictionary<KeyType,ValueType>
{
public:
    DictAsMap();
    virtual ~DictAsMap();
    virtual bool search(const KeyType& k);
    virtual bool search(int k);
...
};

What effect are you trying to achieve?

[vukki]

Virtual functions not allowed to be templates (14.5.2.3). In fact in such code you get partial spec of whole class.
Compare to member templates:

class A
{
template <class B>
void f();
template <class X,class Y>
void g();
};
template<> //full spec
void A::f<int>()
{}
template<> //full spec
void g<int,int>()
{}
template<class B>//error, function template partial specialization is not allowed
void g<B,int>()
{}

[boolivar]

You can derive two classes for two key types:

template <class KeyType, class ValueType>
class Dictionary
{
public:
	virtual bool search(const KeyType& k) = 0;
};

template <class ValueType>
class IntKeyDictionary : public Dictionary<int, ValueType>
{
public:
	virtual bool search(const int& k);
};

template <class ValueType>
class StringKeyDictionary : public Dictionary<std::string, ValueType>
{
public:
	virtual bool search(const std::string& k);
};

Bad base class design hidden by inheritance, however virtual method works:

template <class KeyType, class ValueType>
class Dictionary
{
public:
	virtual bool search(const KeyType& k) = 0;
};

template <class ValueType>
class IntADictionary : public Dictionary<int, ValueType>
{
public:
	virtual bool search(const int& k)
	{
		cout << "Int a search" << endl;
		return true;
	}
};

template <class ValueType>
class IntBDictionary : public Dictionary<int, ValueType>
{
public:
	virtual bool search(const int& k)
	{
		cout << "Int b search" << endl;
		return true;
	}
};

template <class ValueType>
class StringADictionary : public Dictionary<std::string, ValueType>
{
public:
	virtual bool search(const std::string& k)
	{
		cout << "String a search" << endl;
		return true;
	}
};

template <class ValueType>
class StringBDictionary : public Dictionary<std::string, ValueType>
{
public:
	virtual bool search(const std::string& k)
	{
		cout << "String b search" << endl;

		return true;
	}
};

void main ( void )
{
	Dictionary<int, int> *di1 = new IntADictionary<int>;
	Dictionary<int, int> *di2 = new IntBDictionary<int>;

	Dictionary<std::string, int> *ds1 = new StringADictionary<int>;
	Dictionary<std::string, int> *ds2 = new StringBDictionary<int>;

	di1->search(0);
	di2->search(0);

	ds1->search("a");
	ds2->search("a");

	return;
}