C++ templates - design question

[TorAn]

Here is my situation:

class basepolicy
{
public:
   virtual int v1(int) const;
   virtual int v2(int, int) const;
};
 
class policy1 : public basepolicy
{
public:
   int v1(int) const;
};
 
class policy2 : public basepolicy
{
public:
   int v1(int) const;
};

class basepolicy
{
public:
   virtual int v1(int) const;
   virtual int v2(int, int) const;
};

class policy1 : public basepolicy
{
public:
   int v1(int) const;
};

class policy2 : public basepolicy
{
public:
   int v1(int) const;
};

To copy to clipboard, switch view to plain text mode 

derived classes policy1 and policy2 are reimplementing member function v1 and fall back to the implementation of v2 in the base class basepolicy.

Now, classes policy1 and policy2 themselves are an template parameter to another class policySelector.

template<typename T> class policySelector
{
public:
   void select() 
   {
        _t.v1(1); // ok
        _t.v2(1,1); // fails to compile, requires implementation in policy1 and policy2
   }
private:
   T _t;
}
 
void main()
{
	policySelector<policy1> p1;
	policySelector<policy2> p2;
 
	p1.select();
	p2.select();
}

template<typename T> class policySelector
{
public:
   void select() 
   {
        _t.v1(1); // ok
        _t.v2(1,1); // fails to compile, requires implementation in policy1 and policy2
   }
private:
   T _t;
}

void main()
{
	policySelector<policy1> p1;
	policySelector<policy2> p2;

	p1.select();
	p2.select();
}

To copy to clipboard, switch view to plain text mode 

Question: in my project I have many policyX classes, and only few of them require implementation of "v2" member, all
others are OK with default implementation of "v2" in the base class.

According to the compiler I have to provide implementation of v2 in every derived policy class if this class is used
as a template parameter to "policySelector".

Is there a way to restructure the design so I don't have to pollute the code with the identical implementation of v2 in all policy classes?

[SixDegrees]

You don't need to reimplement the function. Just declare it, then in the body make a call to the parents implementation:

derivedPolicy::v2(int i, int j)
{
   basePolicy(i, y);
}

derivedPolicy::v2(int i, int j)
{
   basePolicy(i, y);
}

To copy to clipboard, switch view to plain text mode 

[TorAn]

This is exactly the problem. I have 30+ policyX classes. So, I have to have 30 identical "v2" declaration in each of policyX class.

I'd like to know if there is a pattern that will allow automatic fall to basepolicy.v2 implementation without declaring "v2" method in each and every policyX class.

[Zlatomir]

Your code (the one that you posted should work)
Check your actual project (see if you didn't forgot a public when inherit some classes, or other issues)

Also tell us the actual error that compiler is giving you at that function call.

[TorAn]

Thank you for checking it out. Indeed, it does compile. I failed to carefully check my example against the real code. I'll make changes to match my situation exactly, test it, get my compile error and post modified example here.

[TorAn]

Here is the example that does not compile.

#include "stdafx.h"
#include <iostream>
#include <vector>
 
class A
{
};
 
class B
{
};
 
class Rule
{
public:
	enum ruleStatus
	{
		rsPassed = 1,
		rsFailed = 2,
		rsIncompleteData = 3
	};
 
	Rule()	{}
 
	virtual ~Rule() {}
 
	virtual enum ruleStatus isValid(int i, int j,				const int* tempval, const A& cfd) const;
	virtual enum ruleStatus isValid(int i, int j, const B& pair,const int* tempval, const A& cfd) const;
protected:
};
 
template <typename rulePolicy> class btRuleGeneric : public Rule
{
public:
	btRuleGeneric(): Rule(), _policy(*this){}
 
	enum ruleStatus isValid(int i, int j, const int* tempval, const A& cfd) const
	{
		return _policy.isValid(i, j, tempval,cfd);
	}
 
	enum ruleStatus isValid(int i, int j, const B& pair, const int* tempval, const A& cfd) const
	{
		return _policy.isValid(i, j, pair, tempval,cfd);
	}
private:
	rulePolicy _policy;
};
 
 
class basePolicy
{
public:
	basePolicy(const Rule& rule) : _rule(rule) {};
	virtual Rule::ruleStatus isValid(int i, int j,				  const int* tempval, const A& cfd) const;
	virtual Rule::ruleStatus isValid(int i, int j, const B& pair, const int* tempval, const A& cfd) const;
protected:
	mutable std::string _lasterror;
	const Rule& _rule;
};
 
class myPolicy : public basePolicy
{
public:
	myPolicy(const Rule& rule) : basePolicy(rule) {}
	Rule::ruleStatus isValid(int i, int j, 
		const int* tempval, const A& cfd) const;
 
// compiles OK if this method is uncommented
// 	Rule::ruleStatus isValid(int i, int j, const B& pair,
// 		const int* tempval, const A& cfd) const;
};
 
typedef std::vector<Rule*> coll;
 
int _tmain(int argc, _TCHAR* argv[])
{
	coll lst;
 
	Rule* rule = NULL;
	lst.push_back(new btRuleGeneric<myPolicy>());
 
	return 0;
}

#include "stdafx.h"
#include <iostream>
#include <vector>

class A
{
};

class B
{
};

class Rule
{
public:
	enum ruleStatus
	{
		rsPassed = 1,
		rsFailed = 2,
		rsIncompleteData = 3
	};

	Rule()	{}

	virtual ~Rule() {}

	virtual enum ruleStatus isValid(int i, int j,				const int* tempval, const A& cfd) const;
	virtual enum ruleStatus isValid(int i, int j, const B& pair,const int* tempval, const A& cfd) const;
protected:
};

template <typename rulePolicy> class btRuleGeneric : public Rule
{
public:
	btRuleGeneric(): Rule(), _policy(*this){}

	enum ruleStatus isValid(int i, int j, const int* tempval, const A& cfd) const
	{
		return _policy.isValid(i, j, tempval,cfd);
	}

	enum ruleStatus isValid(int i, int j, const B& pair, const int* tempval, const A& cfd) const
	{
		return _policy.isValid(i, j, pair, tempval,cfd);
	}
private:
	rulePolicy _policy;
};


class basePolicy
{
public:
	basePolicy(const Rule& rule) : _rule(rule) {};
	virtual Rule::ruleStatus isValid(int i, int j,				  const int* tempval, const A& cfd) const;
	virtual Rule::ruleStatus isValid(int i, int j, const B& pair, const int* tempval, const A& cfd) const;
protected:
	mutable std::string _lasterror;
	const Rule& _rule;
};

class myPolicy : public basePolicy
{
public:
	myPolicy(const Rule& rule) : basePolicy(rule) {}
	Rule::ruleStatus isValid(int i, int j, 
		const int* tempval, const A& cfd) const;

// compiles OK if this method is uncommented
// 	Rule::ruleStatus isValid(int i, int j, const B& pair,
// 		const int* tempval, const A& cfd) const;
};

typedef std::vector<Rule*> coll;

int _tmain(int argc, _TCHAR* argv[])
{
	coll lst;

	Rule* rule = NULL;
	lst.push_back(new btRuleGeneric<myPolicy>());

	return 0;
}

To copy to clipboard, switch view to plain text mode 

[Zlatomir]

Aha, you have overloaded functions in there (i should have guessed that)

You will need to override all the overloads of a function, or introduce all of them (their implementation from the Base class) with the using directive.
Something like: <i didn't test it, i don't have VS right now (and saw stdafx... and other stuff that probably i should "hack" to work with Creator ), but it should work fine>

class myPolicy : public basePolicy
{
public:
	myPolicy(const Rule& rule) : basePolicy(rule) {}
 
        using basePolicy::isValid;  //this is what you need to do in every derived class, then you will have your desired behavior
 
	Rule::ruleStatus isValid(int i, int j, 
		const int* tempval, const A& cfd) const;
 
// compiles OK if this method is uncommented
// 	Rule::ruleStatus isValid(int i, int j, const B& pair,
// 		const int* tempval, const A& cfd) const;
};

class myPolicy : public basePolicy
{
public:
	myPolicy(const Rule& rule) : basePolicy(rule) {}
        
        using basePolicy::isValid;  //this is what you need to do in every derived class, then you will have your desired behavior
 
	Rule::ruleStatus isValid(int i, int j, 
		const int* tempval, const A& cfd) const;

// compiles OK if this method is uncommented
// 	Rule::ruleStatus isValid(int i, int j, const B& pair,
// 		const int* tempval, const A& cfd) const;
};

To copy to clipboard, switch view to plain text mode 

[TorAn]

Thank you. You taught me the aspect of "using" directive that I did not encounter before.

A using declaration in a definition of a class A allows you to introduce a name of a data member or member function from a base class of A into the scope of A.