templated functions and derivation

[l2u]

Hello

I have a derived and base class.
From derived class I call templated functions in base class.

For instance:

class base {
public:
	base() { }
	
	template <typename T>
	void somefunction(T t) {
		callback(t);
	}
	
	template <typename T> 	// I want to make it templated to call derived back with templated argument
	virtual void callback(T t) = 0;

}

class derived : public base {
public:
	derived() { }
	
	void callsomefunction() {
		sometype someinst;
		somefunction(someinst);
	}
	
	void callback(sometype t) {	
	}

}

Now I want to callsomefunction() from derived class.
How could I callback (virtual function) from base class with templated argument as you can see in the code?
How could this be possible?
Do I have to make templated base class?

[laserlight]

I have never seen a virtual function template before... but really, what is the bigger picture of what you are trying to solve?

[indigo0086]

Would making that function a friend help?

[l2u]

I call function to serialize data (any object type)..
When data arrives back, base class calls derived class with the same type of data..

Until now I just called virtual function without arguments.

[CornedBee]

Member function templates cannot be virtual. Sorry. It's just not implementable with reasonable effort.

For example, in the most common way of implementing virtual functions, the vtable, you'd need a vtable entry for each template instantiation. How does the compiler know how these are ordered, though? What if one compilation unit contains different instantiations than another? With normal functions, the linker can just fold them together. With virtual functions, that's not possible.

[l2u]

How could I solve this problem then?
Should I make templated class and make typedef inside it that would be used as an argument?

[CornedBee]

Describe your problem in more detail, maybe we can find another solution.

[l2u]

I call templated function in my base class with with smart pointer.
This function reads data from socket and deserializes it to smart pointer.

When deserialization is done, I call virtual function without arguments.

Now I want to call this function with the same smart pointer argument (where data was serialized to).

[laserlight]

No, what you are describing is an attempted solution to your problem. State what is the problem that you are trying to solve.

E.g., instead of saying "I want to create a temporary, assign x to the temporary, assign y to x, then assign the temporary to y", say "I want to swap x and y".

[Sebastiani]

template <typename Derived>
class base
{
        protected:
 
        Derived const &
        derived(void) const
        {
            return static_cast<Derived const&>(*this);
        }
 
        Derived &
        derived(void)
        {
            return static_cast<Derived&>(*this);
        }
 
        public:
 
        template <typename Type>
        void
        put(Type const & data) const
        {
                return derived().put(data);
        }
};
 
#include <iostream>
 
class test : public base<test>
{
        public:
        template <typename Type>
        void
        put(Type const & data) const
        {
                std::cout << data << std::endl;
        }
};
 
template <typename Derived, typename Type>
void
put(base <Derived> const & rhs, Type const & data)
{
        rhs.put(data);
}
 
int
main(void)
{
        put(test(), "foo");
        put(test(), 1024);
}