Public Group

# More Template questions

This topic is 481 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

I start by saying that I am aware that what I am trying to do can easily be achieved trough the <functional> part of the library or trough a Functor or a Lambda, but I wanted to see this in template form.(Code below)

So the first function works, the find_if algorithm find the first value in a vector greater than the specified parameter, but there is no template argument deduction for that function call because the algorithm require a pointer to a function but at that time it is not know I will pass an int into it, and so I need to specify like this:

LargerThan_NoDeduction<30,int>

But this seems ugly because now I have to take care of match the two, like <31.2, double>, and the worst part is that if I now decide to pass something else, like a <'d',char> or a <-10,float> , the function expects a size_t as first template parameter, so this won't do.

So what I wanted to achieve was to pass a predicate to an algorithm in the form of

LargerThan(30)

where the template part of it takes care both of storing the data value (in this case 30, but could be a 'c') and deducing the type we compare from out of it, so in this case int.

So I have a function LargerThan(Type) that returns a function pointer and passes down the value to an helper function which takes both the value and the deduced type, so I don't have to type them myself.

Problem is, this helper function still has an auto in the first template parameter, and the compiler doesn't like this

How would you make this work trough template magics?

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

////
template<size_t TestCase,typename Type>
bool LargerThan_NoDeduction(Type value)
{
return value > TestCase;
}

////
template<typename Type>
auto LargerThan(Type TestCase)-> bool(*)(Type)
{
return LargerThan_helper<TestCase, Type>;
}

template<auto TestCase, typename Type> //auto here is not liked!!!
bool LargerThan_helper(Type value)
{
return value > TestCase;
}
////

int main()
{
vector<int> vec{ 0,11,21,35,67,102 };

//Must specify size and type.
auto p = find_if(vec.begin(), vec.end(), LargerThan_NoDeduction<30,int>);//WORKS
if (p != vec.end()) { cout << *p << endl; }//WORKS

//Deduces type from the value passed.
p = find_if(vec.begin(), vec.end(), LargerThan(30));//ERROR
if (p != vec.end()) { cout << *p << endl; }//ERROR

return 0;
}

Edited by MarcusAseth

##### Share on other sites

Function pointers cannot store extra information. So use something that can:

template<typename Type>
struct LargerThanHelper {
LargerThanHelper(Type value)
: m_value(value) {
}

bool operator()(Type other) {
return other > m_value;
}

private:
Type m_value;
};

template<typename Type>
LargerThanHelper<Type> LargerThan(Type TestCase) {
return LargerThanHelper<Type>(TestCase);
}

##### Share on other sites

So a functor is indeed needed

What about static local variables though? I wonder if one can use it to store the value data inside the innermost function and achieve the same without a functor.

By the way, I totally have no reason to not use functors, I am simply exploring what can be done with templates functions alone

Edited by MarcusAseth

##### Share on other sites

I found a very useless way to have it work without a functor!

Basically the first time it gets instantiated, the TestCase is set and stored inside of it.

Problem is, it can be set only once when instantiated, all the future usage will use that TestCase, pretty useless x_x

Can we improve on it?

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

////
template<typename Type>
auto LargerThan(Type TestCase)-> bool(*)(Type)
{
bool(*func)(Type) = LargerThan_helper<Type>;
func(TestCase);
return func;
}

template<typename Type>
bool LargerThan_helper(Type value)
{
static bool set = false;
static Type TestCase;
if (!set) { TestCase = value; set = true; }
return value > TestCase;
}
////

int main()
{
vector<int> vec{ 0,11,21,35,67,102 };

auto p = find_if(vec.begin(), vec.end(), LargerThan(30)); //p points to 35
if (p != vec.end()) { cout << *p << endl; }

return 0;
}

##### Share on other sites

Man, I thought this time I had it! >_>

There must be a logical error.

My plan was to leverage the overload resolution, so that LargerThan() would call LargerThan_helper() with 2 arguments, and when called with 2 argumens the Unpack function overload would set the static variable used for comparison  to a new value.

All the other time the algorithm would call the LargerThan_helper() which I had passed it trough a pointer, and since the algorithm only passes one value, the other Unpack overload would be called and testCase won't get modified.

I know this is still BS because this now rely on an algorithm passing only 1 value, regardless, what is my logic error in this case?

Why find_if is returning a pointer to 22 rather than 67? Can anyone see the cause?

By the way don't sweat it, I am only fooling around, probably it doesn't matter if this stays an unsolved mistery, though would be interesting to know

EDIT: wait... could it be that by calling it with 2 arguments I am getting a different instantiation than when called with one (I was assuming that the <typename...Args> would count as a single thing, but probably doesnt)?! If that was the case, then the TestCase = 66; would be in the other instantiation, and when the algorithm calls it with 1 value, then the static variable would probably be 0, and the first value in the vector is greater than 0 so I get that as a positive... is that the case? Seems possible, since if I set the first value of the vector to -22, now I get returned the second value... x_x Maybe I'll give up

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

////
template<typename Type>
auto LargerThan(Type TestCase)-> bool(*)(Type)
{
//2 argument are passed in order to call the overload that sets TestCase
LargerThan_helper(TestCase, TestCase);

return LargerThan_helper;
}

template<typename... Args>
bool LargerThan_helper(Args... args)
{
//set TestCase to the type of the first argument
static decltype(Type(args...)) TestCase;

//if 3 argument passed, overload resolution calls
//the function that set TestCase, if 2 argument are passed then
//only the value for the comparison is returned
auto value = Unpack(TestCase, args...);
return value > TestCase;
}

template<typename First,typename... Rest>
First Type(First f,Rest... r) { return f; }

template<typename Type>
Type Unpack(Type& testCase, Type first) { return first; }

template<typename Type>
Type Unpack(Type& testCase, Type first, Type second) { testCase = second; return first; }

int main()
{
vector<int> vec{ 22,11,21,35,67,102 };

auto p = find_if(vec.begin(), vec.end(), LargerThan(66));//WRONG RESULT, returns pointer to 22
if (p != vec.end()) { cout << *p << endl; }

return 0;
}

Edited by MarcusAseth

##### Share on other sites

The major problem with your approach is that you are trying to call into the entry point of this API with a runtime value ("LargerThan(30)"). You cannot transport a runtime value (the parameter 30) to a compile-time constant. The value doesn't exist at compile time.

You can make LargerThan<33>() work:

typedef bool (*Comparison)(int)
template<int Constant>
bool LargerThanImpl(std::size_t other) {
return other > Constant;
}

template<int Constant>
Comparison LargerThan() {
return LargerThanImpl<Constant>;
}

But you cannot deduce a non-type argument from a type argument in a way that would be useful for this until C++17. After C++17, you can use the method detailed in that link, but non-type parameters can only be integers (and a few other things that are irrelevant here), which means you can't work with floats this way.

Give up this static-based approach; it's not a sane solution to the problem; if you really want to accept insane solutions that involve contortions that render the solution unusable in modern, real-world practice, that's your business, but it's a huge waste of time.

##### Share on other sites
1 hour ago, MarcusAseth said:

EDIT: wait... could it be that by calling it with 2 arguments I am getting a different instantiation

Yes. Templates create a family of functions, and each instantiation is basically as unique as if you wrote it out by hand. So that static is not shared between every member of that family. Every member of that family gets its own static, which is (part of) what makes that approach entirely unworkable.

Functions in C++ do not have state, except what state you can encode in their signature (via type meta programming and non-type arguments). But transporting information back in time from runtime to compile-time is impossible.

##### Share on other sites
4 hours ago, jpetrie said:

Give up this static-based approach; it's not a sane solution to the problem; if you really want to accept insane solutions that involve contortions that render the solution unusable in modern, real-world practice, that's your business, but it's a huge waste of time.

Already gave up, never though for a second this was better than using a Function object in any way, just exploring!

Also thanks for all the explanations @jpetrie, really nice to see that template<auto value> coming! I bet eventually it will work with floats too

Edited by MarcusAseth

• ### What is your GameDev Story?

In 2019 we are celebrating 20 years of GameDev.net! Share your GameDev Story with us.

• 12
• 15
• 14
• 46
• 22
• ### Forum Statistics

• Total Topics
634054
• Total Posts
3015275
×