• Advertisement

More Template questions

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 xD

How would you make this work trough template magics? :P

#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 this post


Link to post
Share on other sites
Advertisement

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 this post


Link to post
Share on other sites

So a functor is indeed needed :P

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 this post


Link to post
Share on other sites

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

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? :P

#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 this post


Link to post
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? :S 

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 :P 

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 :P 

#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 this post


Link to post
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 this post


Link to post
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 this post


Link to post
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! xD

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 :P

Edited by MarcusAseth

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now


  • Advertisement
  • Advertisement
  • Popular Tags

  • Advertisement
  • Popular Now

  • Similar Content

    • By LifeArtist
      Good Evening,
      I want to make a 2D game which involves displaying some debug information. Especially for collision, enemy sights and so on ...
      First of I was thinking about all those shapes which I need will need for debugging purposes: circles, rectangles, lines, polygons.
      I am really stucked right now because of the fundamental question:
      Where do I store my vertices positions for each line (object)? Currently I am not using a model matrix because I am using orthographic projection and set the final position within the VBO. That means that if I add a new line I would have to expand the "points" array and re-upload (recall glBufferData) it every time. The other method would be to use a model matrix and a fixed vbo for a line but it would be also messy to exactly create a line from (0,0) to (100,20) calculating the rotation and scale to make it fit.
      If I proceed with option 1 "updating the array each frame" I was thinking of having 4 draw calls every frame for the lines vao, polygons vao and so on. 
      In addition to that I am planning to use some sort of ECS based architecture. So the other question would be:
      Should I treat those debug objects as entities/components?
      For me it would make sense to treat them as entities but that's creates a new issue with the previous array approach because it would have for example a transform and render component. A special render component for debug objects (no texture etc) ... For me the transform component is also just a matrix but how would I then define a line?
      Treating them as components would'nt be a good idea in my eyes because then I would always need an entity. Well entity is just an id !? So maybe its a component?
      Regards,
      LifeArtist
    • By nickyc95
      Hi.
      I'm kind of late to this party but I thought I would ask anyway as I haven't found a concrete answer.
       
      When creating a game engine, when should you choose one methodology over another (more specifically OOP and DOD)? Which areas benefit from DOD? Which areas benefit from OOP? Do people typically mix multiple methodologies throughout a project? I.e. certain sub-systems created in one, and others in the another?  
      DOD - Data Oriented Design
      OOP - Object Oriented Design
       
      Pretty simple
      Thanks
    • By Estra
      Memory Trees is a PC game and Life+Farming simulation game. Harvest Moon and Rune Factory , the game will be quite big. I believe that this will take a long time to finish
      Looking for
      Programmer
      1 experience using Unity/C++
      2 have a portfolio of Programmer
      3 like RPG game ( Rune rune factory / zelda series / FF series )
      4 Have responsibility + Time Management
      and friendly easy working with others Programmer willing to use Skype for communication with team please E-mail me if you're interested
      Split %: Revenue share. We can discuss. Fully Funded servers and contents
      and friendly easy working with others willing to use Skype for communication with team please E-mail me if you're interested
      we can talk more detail in Estherfanworld@gmail.com Don't comment here
      Thank you so much for reading
      More about our game
      Memory Trees : forget me not

      Thank you so much for reading
      Ps.Please make sure that you have unity skill and Have responsibility + Time Management,
      because If not it will waste time not one but both of us
       

    • By mike44
      typedef struct FontInfo_t* FontHandle;
      MichaelNS::FontMgr m;
      MichaelNS::FontHandle FontGeladen;
      const char *FontPtr;
      start:
      InFileFont.append("Ubuntu-B.ttf");
      FontPtr = InFileFont.c_str();
      FontGeladen = m.loadFont(FontPtr, NULL, NULL, 14, 0);
      stop:
          m.unloadFont(FontGeladen);
          delete FontPtr;
      delete causes a crash. How to unload the class correctly?
      Thanks
    • By Cat's machete
      I need to use global vars,
      So say i have main.cpp file where i #include "globalvars.h"
      In globalvars.h i define
      extern int ppp;
      In globalvars.cpp i put #include "globalvars.h"
      int ppp;
       
       
      Now in main cpp during compilation i get UNDEFINED REFERENCE TO ppp
  • Advertisement